JAVA高级教程-Java Collection(1)

一：集合和数组的区别：

1、数组长度固定，集合长度可变
2、数组可以储存基本数据类型和引用数据类型，集合只能存储引用数据类型

collection: 无序，无下标，不能重复
List： 有序，有下标，可以重复

ArrayList: 查询快,增删慢
LinkedList: 增删快，查询慢

泛型：泛型类，泛型方法，泛型接口
语法： T表示类型站位符，表示一种引用数据类型 用啥字母都行
一般用 T=类型 E=元素 K=键 V=值
好处：提高代码的重复性；
防止类型转换异常，提高安全；

二：集合

1、Collection接口的使用（1）

Collection接口的使用
1、添加元素
2、删除元素
3、遍历元素
4、判断

package ArrayList01;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
 * Collection接口的使用
 * 1、添加元素
 * 2、删除元素
 * 3、遍历元素
 * 4、判断
 */

public class day01 {
    public static void main(String[] args) {

        //创建集合
        Collection collection=new ArrayList<>();

        //1、添加元素
        collection.add("张三");
        collection.add("李四");
        collection.add("王五");
        collection.add("小小");

        System.out.println("元素的个数："+collection.size());

        //可以看出ArrayList重写了tostring方法
        System.out.println(collection);

        //2、删除元素1111对方
        collection.remove("王五");
        System.out.println("元素的个数："+collection.size());


        // 3、遍历元素
        //3.1 增强for循环
        System.out.println("====================3.2 增强for循环=====================");
        for(Object i:collection){
            System.out.println(i);
        }

        System.out.println("====================3.2 Iterator迭代器=====================");
        //3.2 Iterator迭代器
        Iterator it=collection.iterator();
        while (it.hasNext()){
            //不能使用Collection.remove删除(),会报并发修改异常
            String s=(String)it.next();
            System.out.println(s);
			//可以使用迭代器删除
            //it.remove();
        }
        
        //* 4、判断
        System.out.println(collection.contains("张三"));
        System.out.println(collection.isEmpty());

    }
}
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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

2、Collection储存对象（2）

package ArrayList01;
import java.util.Objects;

public class Student {

    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;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object obj) {
        //1、判断是不是同一个属性
        if (this == obj) {
            return true;
        }
        //2、判断是否为空
        if (obj == null || getClass() != obj.getClass()) {
            return false;
        }

        //3、判断是否为student类型
        if (obj instanceof Student) {
            Student student = (Student) obj;
            //4、比较属性
            if (this.name.equals(student.getName())&&this.age == student.getAge()) {
                return true;
            }
        }
        //不满足条件，返回false
        return false;

    }

    @Override
    public int hashCode() {
        return Objects.hash(name, 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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

不能使用collection.remove(new Student(“王五”,25));直接移除，应为地址不一样，需要重写equals方法

package ArrayList01;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class day02 {
    public static void main(String[] args) {

        Collection collection=new ArrayList();
        Student s1= new Student("张三",18);
        Student s2= new Student("李四",20);
        Student s3= new Student("王五",25);

        //1、添加数据
        collection.add(s1);
        collection.add(s2);
        collection.add(s3);
        System.out.println("元素的个数："+collection.size());
        System.out.println(collection.toString());


        //删除
        collection.remove(s1);
        //这样是删不掉的，应为有创建了一个新的对象，如果需要这样删除，需要重写equals方法
        //collection.remove(new Student("王五",25));

        System.out.println("删除后的元素的个数："+collection.size());

        // 3、遍历元素
        //3.1 增强for循环
        System.out.println("====================3.2 增强for循环=====================");
        for(Object i:collection){
            Student s=(Student) i;
            System.out.println(s.toString());
        }

        System.out.println("====================3.2 Iterator迭代器=====================");
        //3.2 Iterator迭代器
        Iterator it=collection.iterator();
        while (it.hasNext()){
            //不能使用Collection删除
            Student s=(Student) it.next();
            System.out.println(s);
            //it.remove();
        }

        //* 4、判断
        System.out.println(collection.contains(new Student("张三",18)));

    }
}
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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

3、排序

import java.util.*;

public class Order {

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(8);
        list.add(2);
        list.add(65);
        list.add(34);
        list.add(20);

        System.out.println("排序之前："+list.toString());

        //sort排序
        Collections.sort(list);
        System.out.println("排序之后："+list.toString());

        //查找元素，并返回下标
        int i=Collections.binarySearch(list,8);
        System.out.println(i);

        Collections.reverse(list);
        System.out.println("反转之后："+list.toString());
    }
}
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

4、集合之间的转换

//list转换成数组
        Integer arr[]=list.toArray(new Integer[0]);
        System.out.println(Arrays.toString(arr));

//数组转换成集合  集合是一个受限制的，不能添加删除
        String names[]={"zhan","li","wang"};
        List<String> list2=Arrays.asList(names);
        System.out.println(list2);

//把基本数据类型改为数组，要修改包装类
        Integer numbers[]={1,4,53,5};
        List<Integer> list3=Arrays.asList(numbers);
        System.out.println(list3);
1
2
3
4
5
6
7
8
9
10
11
12
13