Java集合进阶

双列集合

单列集合的特点：一次添加一个。

双列集合的特点：一次添加一对/键值对/键值对对象/Entry。

左键（不可重复）右值（可重复），一一对应。

Map是双列集合的顶层接口，他的功能是全部双列集合都可以继承使用的。

//简单代码例子
import java.util.HashMap;
import java.util.Map;public class jaa {public static void main(String[] args) {//创建Map集合对象Map<String,String>m=new HashMap<>();//添加:put方法//键已经存在，覆盖原有的m.put("lisa","女");m.put("bob","男");m.put("lisa","男");System.out.println(m);//删除m.remove("lisa");System.out.println(m);//清空m.clear();System.out.println(m);//是否包含boolean r=m.containsKey("bob");boolean v=m.containsValue("男");System.out.println(r);System.out.println(m);//是否空boolean is=m.isEmpty();System.out.println(is);//长度int size=m.size();System.out.println(size);}
}

HashMap

特点：是Map里面的一个类，直接用map里的方法。无序，不重复，无索引。哈希表结构（利用键计算哈希值，依赖hashCode和equals方法保证键的唯一）。

//例子
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;public class Main {public static void main(String[] args) {//存学生对象//名和岁数一样认为是一个学生HashMap<student,String>hm=new HashMap<>();student s1=new student("zhangsan",23);student s2=new student("lisi",24);student s3=new student("wangwu",25);student s4=new student("wangwu",25);hm.put(s1,"江苏");hm.put(s2,"浙江");hm.put(s3,"福建");hm.put(s4,"山东");Set<student> keys=hm.keySet();for(student key:keys){String value=hm.get(key);System.out.println(key+"="+value);}}
}

import java.util.Objects;class student {private String name;private int age;public student(String name, int age) {this.name = name;this.age = age;}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;student student = (student) o;return age == student.age &&Objects.equals(name, student.name);}@Overridepublic int hashCode() {return Objects.hash(name, age);}@Overridepublic String toString() {return "student{" +"name='" + name + '\'' +", age=" + age +'}';}
}

LinkedHashMap

有序（存储和取出元素顺序一致），不重复，无索引。哈希表结构（只是每个键值对元素又额外多了一个双链表的机制记录存储的顺序）。

import java.util.*;public class Main {public static void main(String[] args) {LinkedHashMap<String,Integer> lhm=new LinkedHashMap<>();lhm.put("a",1);lhm.put("a",1);lhm.put("b",2);lhm.put("c",3);System.out.println(lhm);}
}

TreeMap

底层和TreeSet一样，都是红黑树结构。

由键决定，不重复，无索引，可排序（对键）。

默认按照键的从小到大进行排序，也可以自己规定键的排序规则。

实现Comparable接口，指定比较规则。

创建集合时传递Comparator比较器对象，指定比较规则。

//默认排序：键的升序//Integer,Double默认升序
//String默认字母ASCII码升序
import java.util.*;public class Main {public static void main(String[] args) {TreeMap<Integer,String> tm=new TreeMap<>();tm.put(4,"ke");tm.put(1,"vn");tm.put(2,"jsidj");tm.put(3,"jd");System.out.println(tm);}
}

//降序
import java.util.*;public class Main {public static void main(String[] args) {TreeMap<Integer,String> tm=new TreeMap<>(new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {return o2-o1;}});tm.put(4,"ke");tm.put(1,"vn");tm.put(2,"jsidj");tm.put(3,"jd");System.out.println(tm);}
}

可变参数

import java.util.*;public class Main {public static void main(String[] args) {//求和，2个数加，3个数加，4个数加，n个数加//可变参数//格式：属性类型...名字//int...argsint sum=getSum(1,2,3,4,6,7,8);System.out.println(sum);}public static int getSum(int...args){int sum=0;for(int i:args){sum=sum+i;}return sum;}
}

集合工具类Collections

1.批量添加方法

2.打乱方法

import java.util.*;public class Main {public static void main(String[] args) {ArrayList<String>list=new ArrayList<>();Collections.addAll(list,"ab","f","dvs","ds","dcs","dw");//批量添加System.out.println(list);//打印Collections.shuffle(list);//打乱System.out.println(list);}
}

创建不可变集合

不可变集合：不可改，一经创建，长度不变，内容不变。

更加安全。

of方法创建不可变集合

List直接用，Set元素不能重复，Map不能重复且键值对最多10个，超过了ofEntries方法。

Stream流

一般结合lambda表达式，简化操作。

得到流，放数据，中间方法和终结方法。

流：流水线

流的获取如下代码：

import javax.sql.rowset.serial.SerialStruct;
import java.util.*;
import java.util.function.Consumer;
import java.util.stream.Stream;public class Main {public static void main(String[] args) {//1.单列集合获取stream流ArrayList<String> list=new ArrayList<>();Collections.addAll(list,"a","b","c","d");
//        Stream<String> stream1=list.stream();
//        stream1.forEach(new Consumer<String>() {
//            @Override
//            public void accept(String s) {
//                System.out.println(s);
//            }
//        });或者list.stream().forEach(s-> System.out.println(s));//2.双列集合无法直接使用Stream//第一种方法HashMap<String,Integer> hm=new HashMap<>();hm.put("a",12);hm.put("b",124);hm.put("c",13);hm.keySet().stream().forEach(s-> System.out.println(s));//第二种方法hm.entrySet().stream().forEach(s-> System.out.println(s));//3.数组获取streamint arr[]={1,2,3,4,5,6,7};Arrays.stream(arr).forEach(s-> System.out.println(s));String arr1[]={"ds","d","w"};Arrays.stream(arr1).forEach(s-> System.out.println(s));//4.零散数据获取stream流（同数据类型）//可以传递数组，但必须是引用数据类型Stream.of(1,2,3,4,5).forEach(s-> System.out.println(s));Stream.of("a","d","s").forEach(s-> System.out.println(s));}
}

 Stream流的中间方法如下：

import javax.sql.rowset.serial.SerialStruct;
import java.util.*;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Stream;public class Main {public static void main(String[] args) {ArrayList<String>list=new ArrayList<>();Collections.addAll(list,"张丽丽","李四","张浩","李四");//1.过滤
//        list.stream().filter(new Predicate<String>() {
//            @Override
//            public boolean test(String s) {
//                return s.startsWith("张");
//            }
//        }).forEach(s-> System.out.println(s));或者这么写list.stream().filter(s->s.startsWith("张")).forEach(s-> System.out.println(s));//2.获取前几个元素list.stream().limit(2).forEach(s-> System.out.println(s));//3.跳过前面几个元素list.stream().limit(2).skip(1).forEach(s-> System.out.println(s));//4.去重list.stream().distinct().forEach(s-> System.out.println(s));//5.合并a,b俩流ArrayList<String>list1=new ArrayList<>();Collections.addAll(list1,"张丽丽","李四","张浩","李四");ArrayList<String>list2=new ArrayList<>();Collections.addAll(list2,"张丽丽");Stream.concat(list1.stream(),list2.stream()).forEach(s-> System.out.println(s));//6.转换流的数据类型ArrayList<String>list3=new ArrayList<>();Collections.addAll(list3,"张丽丽-11","李四-14","张浩-17","李四-14");
//        list3.stream().map(new Function<String, Integer>() {
//            public Integer apply(String s){
//                String[]arr=s.split("-");
//                String ageString=arr[1];
//                int age=Integer.parseInt(ageString);
//                return age;
//            }
//        }).forEach(s-> System.out.println(s));或者list3.stream().map(s->Integer.parseInt(s.split("-")[1])).forEach(s-> System.out.println(s));}
}

流的终结方法如下：

import javax.sql.rowset.serial.SerialStruct;
import java.util.*;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.Predicate;
import java.util.stream.Stream;public class Main {public static void main(String[] args) {ArrayList<String>list=new ArrayList<>();Collections.addAll(list,"a","d","f","s");//遍历list.stream().forEach(s-> System.out.println(s));//统计long count=list.stream().count();System.out.println(count);//收集
//        Object[]arr=list.stream().toArray();
//        System.out.println(Arrays.toString(arr));或者//        list.stream().toArray(new IntFunction<String[]>() {
//            @Override
//            public String[] apply(int value) {
//                return new String[value];
//            }
//        });
//        System.out.println(Arrays.toString(arr));再或者String[] arr2=list.stream().toArray(value ->new String[value]);System.out.println(Arrays.toString(arr2));}
}

收集方法collect

import javax.sql.rowset.serial.SerialStruct;
import java.lang.reflect.Array;
import java.util.*;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;public class Main {public static void main(String[] args) {ArrayList<String> list=new ArrayList<>();Collections.addAll(list,"张无忌-男-15","周芷若-女-14","张强-男-20","赵敏-女-13");//1.收集到list//男List<String>newlist=list.stream().filter(s->"男".equals(s.split("-")[1])).collect(Collectors.toList());System.out.println(newlist);//2.收集到Set//男ArrayList<String> list33=new ArrayList<>();Collections.addAll(list33,"张无忌-男-15","周芷若-女-14","张强-男-20","赵敏-女-13","张强-男-20");Set<String>newlist2=list33.stream().filter(s->"男".equals(s.split("-")[1])).collect(Collectors.toSet());System.out.println(newlist2);//3.收集到Map//男//键值//键不可以重复
//        Map<String,Integer>map=list.stream().filter(s->"男".equals(s.split("-")[1])).collect(Collectors.toMap(new Function<String, String>() {
//                                                                                           @Override
//                                                                                           public String apply(String s) {
//                                                                                               return s.split("-")[0];
//                                                                                           }
//                                                                                       },//前面是键，后面是值。
//                new Function<String, Integer>() {
//                    @Override
//                    public Integer apply(String s) {
//                        return Integer.parseInt(s.split("-")[2]);
//                    }
//                }));//或者这么写Map<String,Integer>map=list.stream().filter(s->"男".equals(s.split("-")[1])).collect(Collectors.toMap(s->s.split("-")[0],s->Integer.parseInt(s.split("-")[2])));System.out.println(map);}
}

小结：

1.Stream流的作用：结合了Lambda表达式，简化集合数组的操作。

2.Stream流的使用步骤：获取stream流对象，使用中间方法处理数据，使用终结方法处理数据。

3.如何获取流：单列集合（默认），双列（不能直接获取），数组（Arrays），零散数据（of）。

4.常见方法：

（中间）filter,limit,skip,distinct,concat,map

（终结）forEach,count,collect

方法引用

把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体。

import javax.sql.rowset.serial.SerialStruct;
import java.lang.reflect.Array;
import java.util.*;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;public class Main {public static void main(String[] args) {//数组倒序Integer[]arr={1,2,4,6,7};//1.匿名内部类Arrays.sort(arr, new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {return o2-o1;}});System.out.println(Arrays.toString(arr));//2.lambbda表达式Arrays.sort(arr,(Integer o1, Integer o2)->{returno2-o1;});System.out.println(Arrays.toString(arr));//简化Arrays.sort(arr,(o1, o2)-> o2-o1);System.out.println(Arrays.toString(arr));//3.方法引用//引用出必须是函数式接口//被引用的方法需要已经存在//被引用方法的形参和返回值需要跟抽象方法的形参和返回值一致//被引用方法的功能需要满足当前的要求Arrays.sort(arr,Main::subtraction);System.out.println(Arrays.toString(arr));}public static int subtraction(int num1,int num2){return num2-num1;}
}

：：（方法引用符）

方法引用分类：

1.引用静态方法：类名::静态方法

import javax.sql.rowset.serial.SerialStruct;
import java.lang.reflect.Array;
import java.util.*;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;public class Main {public static void main(String[] args) {ArrayList<String>list=new ArrayList<>();Collections.addAll(list,"1","2","3");//转化成int//1.常规方式ArrayList<Integer>list2=new ArrayList<>();for (String s : list) {int i=Integer.parseInt(s);list2.add(i);}//2.list.stream().map(new Function<String, Integer>() {@Overridepublic Integer apply(String s) {int i = Integer.parseInt(s);return i;}}).forEach(s-> System.out.println(s));//简化//1.方法已经存在//2.形参和返回值和抽象方法的形参返回值一致//3.方法的功能需要把形参的字符串转化成整数list.stream().map(Integer::parseInt).forEach(s-> System.out.println(s));}
}

2.引用成员方法：对象（this,super,其他类）::成员方法

import javax.sql.rowset.serial.SerialStruct;
import java.lang.reflect.Array;
import java.util.*;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;public class Main {public static void main(String[] args) {ArrayList<String>list=new ArrayList<>();Collections.addAll(list,"张五级","里的","多多","的的");//张开头，三个字list.stream().filter(s->s.startsWith("张")).filter(s->s.length()==3).forEach(s-> System.out.println(s));//匿名内部类list.stream().filter(new Predicate<String>() {@Overridepublic boolean test(String s) {return s.startsWith("张")&&s.length()==3;}}).forEach(s-> System.out.println(s));//改成方法引用list.stream().filter(new Main()::stringjudge).forEach(s-> System.out.println(s));}public boolean stringjudge(String s){return s.startsWith("张")&&s.length()==3;}
}

3.引用构造方法：类名::new

import javax.sql.rowset.serial.SerialStruct;
import java.lang.reflect.Array;
import java.util.*;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;public class Main {public static void main(String[] args) {ArrayList<String>list=new ArrayList<>();Collections.addAll(list,"张无极,15","周芷若,14","张强,20");List<Student> newlist = list.stream().map(new Function<String, Student>() {@Overridepublic Student apply(String s) {String[] arr = s.split(",");String name = arr[0];int age = Integer.parseInt(arr[1]);return new Student(name, age);}}).collect(Collectors.toList());System.out.println(newlist);//或者List<Student> newlist2 = list.stream().map(Student::new).collect(Collectors.toList());System.out.println(newlist2);}
}

public class Student {private String name;private int age;public Student(){}public Student(String str){String[]arr=str.split(",");this.name=arr[0];this.age=Integer.parseInt(arr[1]);}public Student(String name,int age){this.name=name;this.age=age;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public String toString(){return "Student{name="+name+",age="+age+"}";}
}

4.类名引用成员方法

import javax.sql.rowset.serial.SerialStruct;
import java.lang.reflect.Array;
import java.util.*;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;public class Main {
//变大写public static void main(String[] args) {ArrayList<String>list=new ArrayList<>();Collections.addAll(list,"aaa","bbb","ccc");list.stream().map(String::toUpperCase).forEach(s-> System.out.println(s));}
}

5.引用数组的构造方法

import javax.sql.rowset.serial.SerialStruct;
import java.lang.reflect.Array;
import java.util.*;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;public class Main {public static void main(String[] args) {ArrayList<Integer>list=new ArrayList<>();Collections.addAll(list,1,2,3,4,5,6);
//        Integer[] arr = list.stream().toArray(new IntFunction<Integer[]>() {
//            @Override
//            public Integer[] apply(int value) {
//                return new Integer[value];
//            }
//        });//改成方法引用Integer[] arr = list.stream().toArray(Integer[]::new);System.out.println(Arrays.toString(arr));}
}

学不明白回头再写。