List、Set、Map中的方法使用、Stream流、Collections工具类

目录

一、List集合

二、Set集合

三、Map集合

四、Stream流

五、Collections工具类

---

一、List集合

        1.特点

        有序集合,这里的有序指的是存取顺序；用户可以精确控制列表中每个元素的插入位置,用户可以通过整数索引访问元素,并搜索列表中的元素，元素可以重复。

        1.常用方法

方法名	描述
void add(int index,E element)	在此集合中的指定位置插入指定的元素
E remove(int index)	删除指定索引处的元素，返回被删除的元素
E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
E get(int index)	返回指定索引处的元素

代码示例：

public class Test2 {
    public static void main(String[] args) {
        //创建集合对象
        List<Integer> list = new ArrayList<>();
        //添加元素
        list.add(1);
        list.add(2);
        list.add(1);
        list.add(3);
        list.add(4);
        //删除元素,此时删除的是1索引上的元素。
        list.remove(1);
        //手动装箱，把基本数据类型1变为Integer类型,此时删除元素1
        Integer i = Integer.valueOf(1);
        list.remove(i);
        //修改指定索引的元素
        list.set(1,5);
        //获取索引1处的元素
        System.out.println(list.get(1));
        System.out.println("==============");
        System.out.println(list);
    }
}

二、Set集合

        1.Set集合的特点

         不可存储重复元素、无序、没有索引、不能使用普通for循环遍历。

        2.存储字符串的遍历

public class Test2 {
    public static void main(String[] args) {
      	//创建集合对象
        Set<String> set = new TreeSet<>();
      	//添加元素
        set.add("ccc");
        set.add("aaa");
        set.add("aaa");
        set.add("bbb");
//        for (int i = 0; i < set.size(); i++) {
//            //Set集合是没有索引的，所以不能使用通过索引获取元素的方法
//        }      
      	//遍历集合
        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("-----------------------------------");
        for (String s : set) {
            System.out.println(s);
        }
    }
}

        3.自然排序Comparable案例：

存储手机对象并遍历，创建TreeSet集合。要求：按照价格从小到大进行排序，价格相同时，按照姓名的字母顺序排序。

//手机类
public class Phone implements Comparable<Phone>{
    private String brand;
    private int price;
    public Phone() {
    }
    public Phone(String brand, int price) {
        this.brand = brand;
        this.price = price;
    }
    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }
    public int getPrice() {
        return price;
    }
    public void setPrice(int price) {
        this.price = price;
    }
    @Override
    public String toString() {
        return "Phone{" +
                "brand='" + brand + '\'' +
                ", price=" + price +
                '}';
    }

    @Override
    public int compareTo(Phone o) {
        //按照价格排序
        int result=this.getPrice()-o.getPrice();
        //价格相同，按照品牌排序
        result=result==0?this.brand.compareTo(o.getBrand()):result;
        return result;
    }
}

//测试类
public class Test2 {
    public static void main(String[] args) {
        //创建手机对象
        Phone p1=new Phone("小米",3999);
        Phone p3=new Phone("苹果",7999);
        Phone p2=new Phone("小米",5999);
        Phone p4=new Phone("华为",5999);
        //创建集合对象
        TreeSet<Phone>ts=new TreeSet<>();
        //把手机对象添加到集合中
        ts.add(p1);
        ts.add(p2);
        ts.add(p3);
        ts.add(p4);
        //遍历集合
        for (Phone phone : ts) {
            System.out.println(phone);
        }
    }
}

        4.比较器排序Comparator的使用

//存储老师对象并遍历，创建TreeSet集合使用带参构造方法。要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
//老师类
public class Teacher {
    private String name;
    private int age;

    public Teacher() {
    }

    public Teacher(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 "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}


//测试类
public class Test2 {
    public static void main(String[] args) {
      	//创建集合对象
        TreeSet<Teacher> ts = new TreeSet<>(new Comparator<Teacher>() {
            @Override
            public int compare(Teacher o1, Teacher o2) {
                //o1表示现在要存入的那个元素
                //o2表示已经存入到集合中的元素
              
                //主要条件
                int result = o1.getAge() - o2.getAge();
                //次要条件
                result = result == 0 ? o1.getName().compareTo(o2.getName()) : result;
                return result;
            }
        });
		//创建老师对象
        Teacher t1 = new Teacher("zhangsan",23);
        Teacher t2 = new Teacher("lisi",22);
        Teacher t3 = new Teacher("wangwu",24);
        Teacher t4 = new Teacher("zhaoliu",24);
		//把老师添加到集合
        ts.add(t1);
        ts.add(t2);
        ts.add(t3);
        ts.add(t4);
		//遍历集合
        for (Teacher teacher : ts) {
            System.out.println(teacher);
        }
    }
}

三、Map集合

        1.常用方法

方法名	说明
V put(K key,V value)	添加元素
V remove(Object key)	根据键删除键值对元素
void clear()	移除所有的键值对元素
boolean containsKey(Object key)	判断集合是否包含指定的键
boolean containsValue(Object value)	判断集合是否包含指定的值
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合中键值对的个数

代码示例：

public class Test02 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<>();
        //添加元素
        map.put("张三","A");
        map.put("李四","B");
        map.put("王五","C");
        map.put("赵六","D");
        //根据键删除键值对元素
        System.out.println(map.remove("张三"));
        //移除所有键值对元素：map.clear();
        //判断集合是否包含指定的键
        System.out.println(map.containsKey("李四"));
        //判断集合是否包含指定的值
        System.out.println(map.containsValue("B"));
        //判断集合是否为空
        System.out.println(map.isEmpty());
        //int size()：集合的长度，也就是集合中键值对的个数
        System.out.println(map.size());
        //输出集合对象
        System.out.println(map);
    }
}

        2.Map集合的获取方法

方法名	说明
V get(Object key)	根据键获取值
Set<K> keySet()	获取所有键的集合
Collection<V> values()	获取所有值的集合
Set<Map.Entry<K,V>> entrySet()	获取所有键值对对象的集合

示例代码：

public class Test02 {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        map.put("张三","A");
        map.put("李四","B");
        map.put("王五","C");
        map.put("赵六","D");
        //根据键获取值
        System.out.println(map.get("李四"));
        //获取所有键的集合
        Set<String>keyset = map.keySet();
        for (String key : keyset) {
            System.out.println(key);
        }
        System.out.println("-----------------");
        //获取所有值的集合
        Collection<String>values=map.values();
        for (String value : values) {
            System.out.println(value);
        }
        System.out.println("-----------------");
        //获取所有键值对对象的集合.用getKey()得到键;用getValue()得到值
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        for (Map.Entry<String, String> entry : entrySet) {
            String key=entry.getKey();
            String va=entry.getValue();
            System.out.println(key+","+va);
        }
    }
}

四、Stream流

        1.获取Stream流

        获取集合的Stream流

//List生成Stream流
List<String> list = new ArrayList<>();
Stream<String> liststream = list.stream();

//Set生成Stream流
Set<String> set = new HashSet<>();
Stream<String> setstream = set.stream();

//Map生成Stream流
Map<String,String> map = new HashMap<>();
Stream<String> keyStream = map.keySet().stream();
 Stream<String> valueStream = map.values().stream();
Stream<Map.Entry<String, String>> entryStream = map.entrySet().stream();


//数组获取Stream流
String [] name = {"张三","李四","王五"}; 
//数组可以通过Arrays中的静态方法stream生成流     
Stream<String> stream1 = Arrays.stream(name);
//同种数据类型的多个数据可以通过Stream接口的静态方法of生成流
Stream<String> stream2 = Stream.of(name);

        2.Stream流中间操作方法

方法名	说明
Stream<T> filter(Predicate predicate)	用于对流中的数据进行过滤
Stream<T> limit(long maxSize)	返回此流中的元素组成的流，截取前指定参数个数的数据
Stream<T> skip(long n)	跳过指定参数个数的数据，返回由该流的剩余元素组成的流
static <T> Stream<T> concat(Stream a, Stream b)	合并a和b两个流为一个流
Stream<T> distinct()	返回由该流的不同元素（根据Object.equals(Object) ）组成的流

示例代码：

public class Test003 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("赵六");
        list.add("赵六");
        //filter :把集合中以李开头的元素在控制台输出
        list.stream().filter(s->s.startsWith("李")).forEach(System.out::println);
        System.out.println("-------------");
        //limit：取出前两个数据在控制台打印
        list.stream().limit(2).forEach(System.out::println);
        System.out.println("-------------");
        //skip：跳过一个元素，输出剩余元素
        list.stream().skip(1).forEach(System.out::println);
        System.out.println("-------------");
        //concat:合并流
        //取前2个数据作为第一个流
        Stream<String> s1 = list.stream().limit(2);
        //跳过3个数据作为第二个流
        Stream<String> s2 = list.stream().skip(3);
        //合并两个流,输出不同元素
        Stream.concat(s1,s2).distinct().forEach(System.out::println);
    }
}

        3.Stream流的终结方法

方法名	说明
void forEach(Consumer action)	对此流的每个元素执行操作
long count()	返回此流中的元素数

示例代码：

public class Test003 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("赵六");
        //forEach:对流的每个元素进行操作
        list.stream().forEach(System.out::println);
        //统计元素的个数
        long count = list.stream().count();
        System.out.println("此流中元素的个数为："+count);
    }
}

        4.收集操作

方法名	说明
R collect(Collector collector)	把结果收集到集合中

        工具类Collectors收集方法：

方法名	说明
public static <T> Collector toList()	把元素收集到List集合中
public static <T> Collector toSet()	把元素收集到Set集合中
public static Collector toMap(Function keyMapper,Function valueMapper)	把元素收集到Map集合中

代码示例：

public class Test03 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        list.add("赵六七");
        //得到名字为两个字的流
        Stream<String> liststream = list.stream().filter(a->a.length()==2);
        //把操作完的数据手机到List集合中
        liststream.collect(Collectors.toList());
        Set<Integer> set = new HashSet<>();
        set.add(10);
        set.add(20);
        set.add(30);
        set.add(33);
        //得到大于25的流
        Stream<Integer> setStream = set.stream().filter(b->b>25);
        //把操作完的数据手机到Set集合中
        setStream.collect(Collectors.toSet());
    }
}

五、Collections工具类

        常用的方法示例代码：

public class Test03 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        //添加元素
        Collections.addAll(list,"A","C","D","B");
        //反转集合
        Collections.reverse(list);
        //按自然顺序排序
        Collections.sort(list);
        //随机打乱集合中的元素
        Collections.shuffle(list);
        //指定集合中索引i的元素和索引i的元素交换
        Collections.swap(list,0,list.size()-1);
    }
}