JAVA进阶（类集-List接口，Set接口，Iterator接口，Map接口，Stream接口）

一，类集概念

1.类集（Collection）就是一个动态的对象数组

二，List接口

• List接口是Collection接口常用的子接口
• List 接口常用的子类Vector和ArrayList

package 类集;
import java.util.ArrayList;
import java.util.List;
class Person{
    private String name;
    private int age;
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;//就是当前对象
        if (obj == null) return false;
        if (!(obj instanceof Person)) return false;
        Person p = (Person)obj;
        if (this.name.equals(p.name) && this.age==p.age ){
            return true;
        }
        return false;

    }

    @Override
    public String toString() {
        return "姓名："+this.name +" 年龄："+this.age;
    }
}
public class ListDemo {
    public static void main(String[] args)throws Exception {
        //设置泛型，保证集合中所有元素类型一致
        List<String> list = new ArrayList<>();
        //向集合中添加元素，元素可以重复
        list.add("aaa");
        list.add("aaa");
        list.add("huicoder");
        System.out.println("判断集合是否为空："+list.isEmpty()+" 集合长度为："+list.size());
        //修改指定索引的内容
        list.set(0,"bbb");
        //删除集合中元素
        list.remove("aaa");
        for (int i = 0; i < list.size(); i++) {
            //取得指定索引的内容
            String str = list.get(i);
            System.out.println(str);
        }
        List<Person> lp = new ArrayList<>();

        lp.add(new Person("aaa",10));
        lp.add(new Person("bbb",21));
        lp.add(new Person("ccc",23));
        for (int i = 0; i < lp.size(); i++) {
            System.out.println(lp.get(i));
        }
        //集合中特别是对象数据类型的查询与删除必须提供equals()方法，此时需要覆写equals()方法
        lp.remove(new Person("aaa",10));
        System.out.println(lp);
    }
}

三，Set接口

• Set接口并不常用，只是简单的继承Collection接口，Set接口中没有重复元素
• HashSet和TreeSet是常用的子类，HashSet中元素无序存放，TreeSet中元素自动进行排序，顺序存放

package 类集;
import java.util.*;
class Book implements Comparable<Book>{
    private String name;
    private int price;
    public Book(String name, int price)
    {
        this.name = name;
        this.price = price;
    }

    @Override
    public int compareTo(Book o) {
        if(this.price > o.price) return 1;
        else if (this.price < o.price) return -1;
        else return this.name.compareTo(o.name);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Book)) return false;

        Book book = (Book) o;

        if (price != book.price) return false;
        if (!name.equals(book.name)) return false;

        return true;
    }

    @Override
    public int hashCode() {
        int result = name.hashCode();
        result = 31 * result + price;
        return result;
    }

    @Override
    public String toString() {
        return "书名："+this.name +" 价格："+this.price;
    }
}
public class SetDemo {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        //添加数据，集合中没有重复元素，且元素排列是无序的
        set.add("aaa");
        set.add("aaa");
        set.add("bbb");
        set.add("ccc");
        set.add("huicoder");
        System.out.println(set);
        //自动进行集合中元素的排序，且没有重复的元素
        Set<Integer> set1 = new TreeSet<>();
        set1.add(100);
        set1.add(99);
        set1.add(100);
        set1.add(0);
        System.out.println(set1);

        Set<Book> set2 = new HashSet<>();
        set2.add(new Book("java",100));
        set2.add(new Book("java",100));
        set2.add(new Book("c++",100));
        set2.add(new Book("c",80));
        System.out.println(set2);

        Set<Book> set3  = new TreeSet<>();
        set3.add(new Book("java",100));
        set3.add(new Book("java",100));
        set3.add(new Book("c++",100));
        set3.add(new Book("c",80));
        System.out.println(set3);

    }
}

---

四，Iterator接口

• Iterator接口用于集合输出,需要Collection接口中的Iterator()方法取得实例化,顺序迭代输出
• ListIterator双向迭代输出，List专有输出
• Enumeration是Vector类的专有输出

package 类集;
import java.util.*;
public class IteratorDemo {
    public static void main(String[] args) throws Exception{
        Set<String> set = new HashSet<>();
        set.add("0915");
        set.add("0925");
        //第一种输出
        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        //第二种输出
        ListIterator<String> lit = list.listIterator();
        System.out.println("从前向后输出：");
        while (lit.hasNext()) {
            System.out.print(lit.next()+" ");
        }
        System.out.println("\n从后向前输出：");
        while (lit.hasPrevious()){
            System.out.print(lit.previous()+" ");
        }
        System.out.println();
        Vector<String> list1 = new Vector<>();
        list1.add("huicoder");
        list1.add("-java-");
        //第三种输出
        Enumeration<String> en = list1.elements();
        while (en.hasMoreElements()){
            System.out.println(en.nextElement());
        }
        //第四种输出
        for (String str:
             list1) {
            System.out.println(str);
        }
    }
}

五，Map接口

• Collection接口保存一个对象信息，用于输出。Map接口保存一对对象的信息，用于查找
• 常用子类：HashMap允许key或value为空,Hashtable不允许key或value为空

package 类集;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapDemo {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        //向集合中添加元素
        map.put("aaa", 10);
        map.put("aaa", 20);
        map.put("bbb", 20);
        map.put(null,100);
        map.put("xxx",null);
        //使用HashMap定义的Map集合，元素无序存放，如果出现重复的key值，新的内容会替换旧的内容
        System.out.println(map);
        //根据key值取value
        map.get("aaa");

        Set<String> set = map.keySet();//取得全部的key 返回Set类型
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }

        System.out.println("使用Iterator进行Map集合的输出:");
        //Map集合转化为Set集合
        Set<Map.Entry<String,Integer>> set1 = map.entrySet();
        //得到Iterator输出对象
        Iterator<Map.Entry<String,Integer>> it1 = set1.iterator();
        while (it1.hasNext()){
            Map.Entry<String,Integer> me = it1.next();
            System.out.println(me.getKey()+" " +me.getValue());
        }


    }
}

六，Stream接口

• Stream接口的主要作用是进行数据分析处理操作
• Collection接口中提供了实例化Stream的函数

public class StreamDemo {
    public static void main(String[] args) throws Exception{
        List<String> list = new ArrayList<>() ;
        list.add("aaa");
        list.add("bbb");
        list.add("bbb");
        list.add("aaa");
        // 得到stream对象，可以对Collection集合中数据进行加工
        Stream<String> stream = list.stream();
        // 得到数据个数
        //System.out.println(stream.count());
        // 消除重复数据，进行过滤
        System.out.println(stream.distinct().count());
        }
  }

• 进行数据采集1

public class StreamDemo {
    public static void main(String[] args) throws Exception{
        List<String> list = new ArrayList<>() ;
        list.add("aaa");
        list.add("bbb");
        list.add("bbb");
        list.add("aaa");
        // 得到stream对象，可以对Collection集合中数据进行加工
        Stream<String> stream = list.stream();
        // 收集器，对重复数据过滤，收集，形成一个新的集合中不包含重复数据
        List<String> list1 = stream.distinct().collect(Collectors.toList());
        System.out.println(list1);
        }
   }

• 进行数据采集2------>取出带有‘e’的单词

public class StreamDemo {
    public static void main(String[] args) throws Exception{
        List<String> list = new ArrayList<>() ;
        list.add("immune");
        list.add("LOVE");
        list.add("Huicoder");
        list.add("2020-10-30");
        Stream<String> stream = list.stream();
        //使用了断言式函数式接口，借用Lamba表达式
        //进行条件过滤前先进行数据处理，map作用就是对数据进行逐行处理
        List<String> list1 = stream.distinct().map((x) -> x.toLowerCase()).filter((x) -> x.contains("e")).collect(Collectors.toList());
        System.out.println(list1);
        }
    }

• 进行数据的分页处理：设置跳过的行数skip()；设置取出数据的个数limit()

public class StreamDemo {
    public static void main(String[] args) throws Exception{
         //进行集合数据分页操作
        List<Integer> list = new ArrayList<>() ;
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(1);
        Stream<Integer> stream = list.stream();
        // 进行去重操作，跳过一个数据后，取出一个数据
        List<Integer> list1  = stream.distinct().skip(1).limit(1).collect(Collectors.toList());
        System.out.println(list1);}
        }

• 进行数据查询操作

public class StreamDemo {
    public static void main(String[] args) throws Exception{
        //数据的全匹配和部分匹配，进行查询操作,多条件匹配用and或者or
        List<String> list = new ArrayList<>();
        list.add("immune");
        list.add("LOVE");
        list.add("Huicoder");
        list.add("2020-10-30");
        Stream<String> stream = list.stream();
        Predicate<String> p1 = (x) -> x.contains("immune");
        Predicate<String> p2 = (x) -> x.contains("Huicoder");

        if (stream.anyMatch(p1.or(p2))){
            System.out.println("数据存在");
        }
     }
  }

• 与MapReduce结合使用

package 类集;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;
class Shopping{
    private String name;
    private double price;
    private int count;

    public Shopping(String name, double price, int count) {
        this.name = name;
        this.price = price;
        this.count = count;
    }

    public String getName() {
        return name;
    }

    public double getPrice() {
        return price;
    }

    public int getCount() {
        return count;
    }
}
//Stream接口进行集合数据的输出
public class StreamDemo {
    public static void main(String[] args) throws Exception{
        //MapReduce与Stream结合
        List<Shopping> list = new ArrayList<>();
        list.add(new Shopping("可乐",5,2));
        list.add(new Shopping("芬达",3.5,3));
        list.add(new Shopping("农夫山泉",2,10));

        Stream stream = list.stream().map((x) ->x.getName()+": " + x.getCount()*x.getPrice());
        double s = list.stream().map((x) ->x.getCount()*x.getPrice()).reduce((sum,m) -> sum + m).get();
        List list1 = (List) stream.collect(Collectors.toList());
        System.out.println(list1);
        System.out.println("总金额："+s);
    }
}