java基础之Arraylise的使用_为什么用printarraylist(list)不用system.out.println

Arraylise的简介与使用方法

通常在Java中数组的长度是不会改变的但是Arraylise数组则可以进行改变
在使用Arraylise数组时会发现往往后面会跟一个<>这个<>代表的是泛型的意思，泛型就是固定这个集合的所有类型都是统一类型 泛型只能是引用类型 不能是基本类型。
1.在这里我定义了一个Arraylise数组命名为list
注：在java7y以上就只用在数组的左边的<>中定义类型，在右边的<>不需要再进行定义。

public class Dome02Arraylist {
    public static void main(String[] args) {
        ArrayList<String> list = new  ArrayList<>();
1
2
3

2.在打印输出时空的Arraylist数组不是打印出地址值而是会出现一个[ ]

 System.out.println(list);
 输出结果为[]
1
2

3.向数组中添加数据时只需要数组名加上.add就可进行添加，并且在打印输出Arraylist的多个数据会用，隔开。

  list.add("二傻");
        System.out.println(list);
        list.add("大傻");
        System.out.println(list);
1
2
3
4

ArrayList数组的使用方法

. 注：E表示泛型前面有解释

1. public bollean add(E e) 添加数组

 public static void main(String[] args) {
        ArrayList<String>list=new ArrayList<>();
        boolean name =list.add("大傻");
        //这里返回值写出 boolean 为了确定是否加入成功，一般添加数组不用定义，应为加入一般肯定成功
        System.out.println(list);
        System.out.println("是否加入数组成功"+name);
        
1
2
3
4
5
6
7

2. public E get(int index) 从集合当中获取元素 参数是索引编号，返回值就是对应位置的元素

 String s =list.get(0);
        System.out.println(list);
1
2

3. public int size() 获取集合尺寸长度，返回值集合中包含元素各数

 int sise=list.size();
        System.out.println(sise);
1
2

4. public E remove (int index) 从集合当中删除元素，参数是索引编号，返回值就是被删除掉的元素

在这里插入 String names=list.remove(0);
        System.out.println("别删除的人是"+names);
        System.out.println(list);
        
1
2
3
4

遍历ArrayList元素

  ArrayList<String> list = new ArrayList<>();
        list.add("大傻");
        list.add("二傻");
        list.add("三傻");
        for(int i =0;i<list.size();i++)
        System.out.println(list.get(i));
1
2
3
4
5
6

ArrayList 存储卡基本数据类型

如果想要集合ArrayLise当中存储基本数据，必须使用基本数据对应“包装类”

    ArrayList<Integer> list = new ArrayList<>();
         list.add(100);
         list .add(200);

        System.out.println(list);
        //如何拿出数据
        int num = list.get(0);
        System.out.println("我获取的第一个元素是"+num);
1
2
3
4
5
6
7
8

关于ArrayList的练习题

1.随机生成6个1~33的数，并且添加进集合并进行遍历

public class ArrayListRandom {
    public static void main(String[] args) {
        //先创建一个集合
        ArrayList<Integer> list= new ArrayList<>();
        //使用随机数方法
        Random r = new Random();
        //循环六次，得到六个数
        for (int i = 0; i < 6; i++) {
            //应为随机数是从零开始所以要在后面加一个一
            int num=r.nextInt(33)+1;
            //将得到的六个随机数添加进集合当中
            list.add(num);
        }
        //将集合中的数进行遍历输出
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2. 自定义四个学生对象，添加到集合并遍历输出
   . 首先定义一个完整的学生类，代码如下

private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

. 之后在建一个类用于添加集合和遍历

public class Dome02ArrayListStudent {
    public static void main(String[] args) {
        ArrayList<Student> list= new ArrayList<>();
        //向Student添加进数据
        Student one = new Student("大傻",20);
        Student two = new Student("二傻",21);
        Student three = new Student("三傻",22);
        //将数据添加进集合当中
        list.add(one);
        list.add(two);
        list.add(three);
        // 遍历集合
       for (int i = 0; i < list.size(); i++) {
           //将集合list赋值给stu
          Student stu= list.get(i);
           System.out.println("姓名"+stu.getName()+"年龄"+stu.getAge());
        }

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3. 自定义一个指定格式打印输出集合的方法（ArrayList类型作为参数）使用{}扩起集合，使用@分隔每个元素

public class Dome03ArrayListPrint {
    public static void main(String[] args) {
        ArrayList<String> list= new ArrayList<>();
        list.add("大傻");
        list.add("二傻");
        list.add("三傻");
        System.out.println();
        //调用自定义的方法
        printArrayList(list);
    }
    /*
    定义方法的三要素
    1.看返回值是何类型此处定义的方法只是用于返回列表无属性 使用viod
    2.方法名称 printArrayList
    3.参数列表 ArrayList<String> list
    */
    //自定义一个方法
    public static void printArrayList(ArrayList<String> list){
        System.out.print("{");
        //进行遍历
        for (int i = 0; i < list.size(); i++) {
            String name=list.get(i);
            //进行判断是否为最后一位属性
            if(i == list.size()-1){
                System.out.print(name+"}");
            }else{
                System.out.print(name+"@");
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

4. 用一个大集合存入20个随机数数字，然后筛选其中的偶函数，放到小集合打当中，要求自定义范方法来实现

public class Dome04ArrayListReturn {
    public static void main(String[] args) {
        ArrayList<Integer> bigList = new ArrayList<>();
        Random r =new Random();
        for (int i = 0; i < 20; i++) {
            int num = r.nextInt(100) + 1;
            bigList.add(num);
        }
        //定义一个集合用于调用方法
          ArrayList<Integer> Return =getSmallist(bigList);
            System.out.println("偶数的总数为"+Return.size());
            for (int s = 0; s < Return.size(); s++) {
                System.out.println(Return.get(s));
            }
        }

      //定义一个方法
    public  static  ArrayList<Integer> getSmallist (ArrayList<Integer> bigList){
        //在方法中定义一个小集合用于保存偶数
        ArrayList<Integer> samlList =new ArrayList<>();
        for (int i = 0; i < bigList.size(); i++) {
          int num=  bigList.get(i);
            if(num % 2 ==0){
                samlList.add(num);
            }
        }
        //返回samList
        return samlList;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31