JavaSE 进阶 (7) 集合

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

public static void main(string[] args){
	HashSet<String> hs = new HashSet<>();
	
	hs.add("hello");
	hs.add("world");
	hs.add("java");
	hs.add("java");
	hs.add("java");
	hs.add("java");
	hs.add("java");
	hs.add("java");

	Iterator<String> it = hs.iterator();
	while(it.hasNext()){
		String s = it.next();
		System.out.println(s);
	}

	System.out.println("=============================");

	for(String s : hs){
		System.out.println(s);
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

/**
 * 计算哈希值
*/
public class HashSetDemo2{
	public static void main(string[] args){
		Student s1 = new Student("xiaozhi", 23);
		Student s2 = new Student("xiaomei", 22);

		//因为在Object类中，是根据对象的地址值计算出来的哈希值。
		System.out.println(s1.hashcode()); //1060830840
		System.out.println(s1.hashcode()); //1060830840
		
		System.out.println(s2.hashCode()); //2137211482
	}
}

1
2
3
4
5
6

@Override
public int hashCode() {
	int result = name != null ? name.hsahCode() : 0;
	result = 31 * result + age;
	return result;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

public class HashSetTest1{
	public static void main(String[] args){
		HashSet<Student> hs = new HashSet<>();
		Student s1 = new Student("xiaohei", 23);
		Student s2 = new Student("xiaohei", 23);
		Student s3 = new Student("xiaomei", 22);

		hs.add(s1);
		hs.add(s2);
		hs.add(s3);
		
		for (Student student : hs){
			System.out.println(student);
		}
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

/**
 * map的基本使用 
*/
public class MyMap1{
	public static void main(String[] args){
		Map<String,String> map = new HashMap<>();

		map.put("001", "小智");
		map.put("002", "小美");
		map.put("003", "大胖");
		
		System.out.println(map);
	}
}

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

public class MyMap2{
	public static void main(String[] args){
		Map<String,String> map = new HashMap<>();
		// V put(K key, V value)  添加元素
		//如果要添加的键不存在，那么会把键值对都添加到集合中
		//如果要添加的键是存在的，那么会覆盖原先的值，把原先值当做返回值进行返回。
		map.put("001", "小智");
		map.put("002", "小美");
		map.put("003", "大胖");
		map.put("004", "小黑");
		map.put("005", "大师");

		String s = map.put("001","aaa");
		System.out.println(s);  //"小智"
		System.out.println(map);
	}
}

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

public class MyMap3{
	public static void main(String[] args){
		//创建集合并添加元素
		Map<String,String> map = new HashMap<>();
		map.put("1号丈夫","1号妻子");
		map.put("2号丈夫","2号妻子");
		map.put("3号丈夫","3号妻子");
		map.put("4号丈夫","4号妻子");
		map.put("5号丈夫","5号妻子");

		//获取到所有的键
		Set<string> keys = map.keyset();

		//遍历Set集合得到每一个键
		for(String key : keys){
			//通过每一个键key,来获取到对应的值
			string value = map.get(key);
			System.out.println(key + "---" + value);
		}
	}
}

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

public class MyMap4{
	public static void main(String[] args){
		//创建集合并添加元素
		Map<String,String> map = new HashMap<>();
		map.put("1号丈夫","1号妻子");
		map.put("2号丈夫","2号妻子");
		map.put("3号丈夫","3号妻子");
		map.put("4号丈夫","4号妻子")
		map.put("5号丈夫","5号妻子");

		//首先要获取到所有的键值对对象。
		//Set集合中装的是键值对对象(Entry对象)
		//而Entry里面装的是键和值
		Set<Map.Entry<String,String>> entries = map.entryset();
		for(Map.Entry<string,string> entry : entries){
			//得到每一个键值对对象
			String key = entry.getkey();
			String value = entry.getvalue();
			System.out.println(key + "---" + value);
		}
	}
}

1
2
3
4
5
6
7

public static void main(String[] args) {
    HashMap<Student,String> hs = new HashMap<>();
    Set<Student> students = hs.keySet();
    hs.forEach((Student key, String val) -> {
        System.out.println(key + "---" + val);
    });
}

 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

public class MyMap5{
	public static void main(String[] args){
		HashMap<Student,String> hm = new HashMap<>();
		Student s1 = new Student("xiaohei", 23);
		Student s2 = new Student("dapang", 22);
		Student s3 = new Student("xiaomei", 22);
		
		hm.put(s1,"江苏");
		hm.put(s2,"北京");
		hm.put(s3,"天津");
		
		//第一种：先获取到所有的键，再通过每一个键来找对应的值
		Set<Student> keys = hm.keyset();
		for (Stndent key : keys){
			String value = hm.get(key);
			System.out.println(key + "----" + value);
		}
		
		//第二种：先获取到所有的键值对对象。再获取到里面的每一个键和每一个值
		Set<Map.Entry<Student,String> >entries = hm.entryset();
		for(Map.Entry<Student,string> entry : entries){
			Student key = entry.getkey();
			String value = entry.getvalue();
			System.out.println(key + "----" + value);
		}
		
		//第三种：通过foreach方法，给一个函数式接口biConsumer的匿名实现类
		hm.forEach(
			(Student key, String value)->{
				system.out.println(key + "----" + value);
			}
		);
		
	}
}

 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

public class Student implements comparable<Student>{
	private string name;
	private int age;
	
	public student(){
	}

	public Student(string name,int age){
		this.name = name;
		this.age = age;
	}
	
	//set/get...
	
	@Override
	public String toString(){
		return "student{"+
				"name='" + name +'\'' +
				", age=" + age +
				'}';
	}
	
	@Override
	public int compareTo(Student o){
		//按照年龄进行排序
		int result = this.getAge() - o.getAge();
		//次要条件，按照姓名排序。

		result = result == 0 ? this.getName().compareTo(o.getName()) : result;
		return result;
	}
}

public class Test1{
	public static void main(String[] args){
		TreeMap<Student,String> tm = new TreeMap<>();
		Student s1 = new Student("xiaohei", 23);
		Student s2 = new Student("dapang", 22);
		Student s3 = new Student("xiaomei", 22);
		
		tm.put(s1,"江苏");
		tm.put(s2,"北京");
		tm.put(s3,"天津");
	}
}

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

//匿名内部类的形式
public class Test1{
	public static void main(String[] args){
		TreeMap<Student,String> tm = new TreeMap<>(new Comparator<Student>(){
			@Override
			public int compare(Student o1,Student o2){
				int result = o1.getAge() - o2.getage();
				result = result == 0 ? o1.getName().compareTo(o2.getName()) : result;
				return result;
		});
		
		Student s1 = new Student("xiaohei", 23);
		Student s2 = new Student("dapang", 22);
		Student s3 = new Student("xiaomei", 22);
		
		tm.put(s1,"江苏");
		tm.put(s2,"北京");
		tm.put(s3,"天津");
	}
}

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

/**
* 需求：定义一个方法求N个数的和
*/
public class MyVariableParameter2{
	public static void main(String[] args){
		//在JDK5之前，会把所有的数据都先放到一个数组中
		//我们自己定义的方法，形参只要写一个数组就可以了。
		int[] arr = {1, 2, 3, 4, 5};
		int sum1 = getSum(arr);
		System.out.println(sum1);
	}
	
	private static int getSum(int[] arr){
		int sum = 0;
		for(int i = 0; i < arr.length; i++){
			sum = sum + arr[i];
		}
		return sum;
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

public class MyVariableParameter3{
	public static void main(String[] args){
		int sum1 = getsum(1, 2, 3, 4, 5);
		System.out.println(sum1);
	}

	public static int getsum(int...arr){
		int sum = 0;
		for(int i = 0; i < arr.length; i++){
			sum = sum + arr[i];
		}
		return sum;
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

public class MyVariableParameter3{
	public static void main(String[] args){
		int sum1 = getsum(number: 1, ...arr: 2, 3, 4, 5);
		System.out.println(sum1);
	}

	public static int getsum(int number, int...arr){
		int sum = 0;
		for(int i = 0; i < arr.length; i++){
			sum = sum + arr[i];
		}
		return sum;
	}
}

1

List<Integer> List = Arrays.asList(1,2,3,4,5);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public class Test{
	public static void main(String[] args){
		List<string> list = List.of("a","b","c","d");
		System.out.println(list);
		//list.add("Q");     //报错
		//list.remove("a");  //报错
		//list.set(0, "A");  //报错
		System.out.println(list);
	}
}

1
2
3
4
5

//集合的批量添加
//首先是通过调用 List.of 方法来创建一个不可变的集合，of 方法的形参就是一个可变参数。
//再创建一个 ArrayList 集合，并把这个不可变的集合中所有的数据，都添加到 ArrayList 中。
ArrayList<string> list3 = new ArrayList<>(List.of("a","b","c","d"));
System.out.println(list3);

1
2
3
4
5
6
7
8

public class TestDemo04 {
    public static void main(String[] args) {
        List<Integer> list = List.of(1, 2, 3, 4, 5);

        List<Integer> list2 = new ArrayList<>(list);
        list2.add(6);
    }
}

1
2

//传递的参数当中，不能存在重复的元素，有重复的数据，会报错
Set<string> set = Set.of("a", "b", "d", "a");

1
2
3
4
5

Map<String, String> map = Map.of(
    "zhangsan", "江苏",
    "lisi", "北京",
    "wangwu", "天津"
);

1
2
3
4

Map<String,String> map = Map.ofEntries(
		Map.entry("zhangsan","江苏"),
		Map.entry("Iisi",:"北京"));
System.out.println(map);

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

public class Collections_Demo {
    public static void main(String[] args) {
    //演示 : Collections类常用方法
        List list = new ArrayList();
        list.add(141);
        list.add(233);
        list.add(666);
        list.add(211);
        list.add(11);
        list.add(985);
        list.add(24);
        list.add(5);
        System.out.println("当前集合 = " + list);
 
        //1.static void reverse(List<?> list) : 反转List集合中元素的顺序
        Collections.reverse(list);
        System.out.println("反转后的集合 = " + list);
    }
}

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

public class Collections_Demo {
    public static void main(String[] args) {
    //演示 : Collections类常用方法
        List list = new ArrayList();
 
        list.add("Cyan");
        list.add("RA9");
        list.add("CSDN YYDS");
        list.add("Ice");
        list.add("Bob");
        list.add("Kyrie");
        list.add("Irving");
        System.out.println("当前集合 = " + list);
        //2.static void shuffle(List<?> list) : “洗牌”
        Collections.shuffle(list);
        System.out.println("洗牌后的集合 = " + list);
        Collections.shuffle(list);
        System.out.println("洗牌后的集合 = " + list);
        Collections.shuffle(list);
        System.out.println("洗牌后的集合 = " + list);
    }
}

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

public class Collections_Demo {
    public static void main(String[] args) {
    //演示 : Collections类常用方法
        List list = new ArrayList();
        list.add(141);
        list.add(233);
        list.add(666);
        list.add(211);
        list.add(11);
        list.add(985);
        list.add(24);
        list.add(5);
        System.out.println("当前集合 = " + list);
 
        //3.static void sort(List<T> list) : 升序排序
        Collections.sort(list);
        System.out.println("排序后的集合 = " + list);
    }
}

 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 Collections_Demo {
    public static void main(String[] args) {
    //演示 : Collections类常用方法
        List<Integer> list = new ArrayList();
        list.add(141);
        list.add(233);
        list.add(666);
        list.add(211);
        list.add(11);
        list.add(985);
        list.add(24);
        list.add(5);
        System.out.println("当前集合 = " + list);
 
        //4.static <T> void sort(List<T> list, Comparator<? super T> c) : 指定排序
        Collections.sort(list, new Comparator<Object>() {
            @Override
            public int compare(Object o1, Object o2) {
            	return (Integer)o2 - (Integer)o1;
            }
        });

        System.out.println("排序后的集合 = " + list);
    }
}

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

public class Collections_Demo {
    public static void main(String[] args) {
    //演示 : Collections类常用方法
        List list = new ArrayList();
        list.add(141);
        list.add(233);
        list.add(666);
        list.add(211);
        list.add(11);
        list.add(985);
        list.add(24);
        list.add(5);
        System.out.println("当前集合 = " + list);
 
        //5.static void swap(List<?> list, int i, int j) : 指向元素进行交换
        Collections.swap(list, 0, list.size() - 1);
 
        System.out.println("交换元素后的集合 = " + list);
    }
}

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

public class Collections_Demo {
    public static void main(String[] args) {
    //演示 : Collections类常用方法
        List list = new ArrayList();
        list.add(141);
        list.add(233);
        list.add(666);
        list.add(211);
        list.add(11);
        list.add(985);
        list.add(24);
        list.add(5);
        System.out.println("当前集合 = " + list);
 
        //6.static T max(Collection<? extends T> coll) : 获取集合中的最大值
        int max = (int) Collections.max(list);
        
        System.out.println("当前集合中最大的元素 = " + max);
    }
}

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

public class Collections_Demo {
    public static void main(String[] args) {
    //演示 : Collections类常用方法
        List list = new ArrayList();
        list.add(141);
        list.add(233);
        list.add(666);
        list.add(211);
        list.add(11);
        list.add(985);
        list.add(24);
        list.add(5);
        System.out.println("当前集合 = " + list);
 
        //7.static T min(Collection<? extends T> coll) : 获取集合中的最小值
        int min = (int) Collections.min(list);
 
        System.out.println("当前集合中最小的元素 = " + min);
    }
}

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

public class Collections_Demo {
    public static void main(String[] args) {
    //演示 : Collections类常用方法
        List list = new ArrayList();
        list.add(141);
        list.add(233);
        list.add(666);
        list.add(5);
        list.add(11);
        list.add(11);
        list.add(11);
        list.add(5);
        System.out.println("当前集合 = " + list);
 
        //8.static int frequency(Collection<?> c, Object o) ：获取指定元素在指定集合中出现的次数
        int times_0 = Collections.frequency(list, 11);
        int times_1 = Collections.frequency(list, 233);
        int times_2 = Collections.frequency(list, 5);
 
        System.out.println("11在list集合中出现的次数 = " + times_0);
        System.out.println("233在list集合中出现的次数 = " + times_1);
        System.out.println("5在list集合中出现的次数 = " + times_2);
    }
}

 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

public class Collections_Demo {
    public static void main(String[] args) {
    //演示 : Collections类常用方法
        List list = new ArrayList();
        list.add(141);
        list.add(233);
        list.add(666);
        list.add(5);
        list.add(11);
        list.add(11);
        list.add(11);
        list.add(5);
        System.out.println("当前集合 = " + list);
 
        //9.static <T> void copy(List<? super T> dest, List<? extends T> src) : 将旧集合中的内容拷贝到新集合中
        List list2 = new ArrayList();
        try {
            Collections.copy(list2, list);
        } catch (Exception e) {
            System.out.print("新集合的长度小于旧集合时不能直接拷贝，否则抛出以下异常：");
            System.out.println(e.toString());
        }
 
        for (int i = 0; i < list.size(); ++i) {
            list2.add(null);
        }
 
        Collections.copy(list2, list);
        System.out.println("拷贝后的新集合 = " + list2);
    }
}

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

public class Collections_Demo {
    public static void main(String[] args) {
    //演示 : Collections类常用方法
        List list = new ArrayList();
 
        list.add("Cyan");
        list.add("RA9");
        list.add("CSDN YYDS");
        list.add("Cyan");
        list.add("Cyan");
        list.add("Kyrie");
        list.add("Irving");
        System.out.println("当前集合 = " + list);
        //10.static <T> boolean replaceAll(List<T> list, T oldVal, T newVal) : 用新值替换集合中的旧值
        Collections.replaceAll(list, "Cyan", "Ice");
        System.out.println("将\"Cyan\"全部替换为\"Ice\"后，集合为 = ");
        System.out.println(list);
    }
}