大数据学习记录，Java基础（6）

集合

Java集合框架体系

• Java 集合可分为 Collection 和 Map 两种体系：
  • Collection接口：单列数据，定义了存取一组对象的方法的集合
    • List：元素有序、可重复的集合
    • Set：元素无序、不可重复的集合
  • Map接口：双列数据，保存具有映射关系“key-value对”的集合

Collection接口的方法

• add：添加元素对象到当前集合中
• addAll：添加一个集合中的所有元素对象到当前集合中
• boolean isEmpty()：判断当前集合是否为空集合。
• int size()：获取当前集合中实际存储的元素个数

Iterator接口

Iterator 仅用于遍历集合，Iterator 本身并不提供承装对象的能力。如果需要创建 Iterator 对象，则必须有一个被迭代的集合。

 public void test02(){
        Collection name = new ArrayList();
        name.add("小王");
        name.add("小芳");
        name.add("小红");

        Iterator iterator = name.iterator();//获取迭代器对象
        while(iterator.hasNext()) {//判断是否还有元素可迭代
            System.out.println(iterator.next());//取出下一个元素
        }
    }

List【接口】

List: 元素有序【存储和取出的顺序一致】，允许元素发生重复，具有索引的概念

public static void main(String[] args) {
    //借助ArrayList实现子类创建List接口的对象
    List list1 = new ArrayList();
    //在list中添加元素
    list1.add("hello");
    list1.add("world");
    list1.add("apple");
    list1.add("hadoop");
    list1.add("redis");
    list1.add("world");
    
    //迭代器遍历
    Iterator iterator = list1.iterator();
    while (iterator.hasNext()){
    System.out.println(iterator.next());
}
}

List集合具有索引的概念，根据索引提供了List集合特有的一些功能：

//在索引三的位置上添加一个元素
list1.add(3,"数加");

//根据索引删除元素并返回被删除的元素
System.out.println(list1.remove(10));

//通过索引获取元素
System.out.println(list1.get(3));

//根据索引修改值并返回索引位置上的旧值
System.out.println(list1.set(3, "shujia"));

//

List的实现类

• ArrayList:底层数据结构是数组，查询快，增删慢
• LinkedList：底层数据结构是双链表，查询慢，增删快

Set【接口】

Set: 元素唯一且无序

HashSet

HashSet的底层数据结构是哈希表，保证了元素的唯一性

 public static void main(String[] args) {
     // HashSet() 构造一个新的空集合; 背景HashMap实例具有默认初始容量（16）和负载因子（0.75）。
     HashSet<String> set1 = new HashSet<>();
     // 因为Set是Collection的子接口，HashSet是Set接口的实现类，里面必然也重写了父接口中所有的抽象方法
     set1.add("hello");
     set1.add("world");
     set1.add("hello");
     set1.add("java");
     set1.add("hello");
     set1.add("hadoop");
     for (String s : set1) {
         System.out.println(s);//world java hello hadoop
     }
 }

TreeSet

TreeSet的底层数据结构是红黑树，可排序

排序方式：
1) 自然排序

自然排序要求元素类要实现Comparable接口，并重写compareTo方法,compareTo方法中的结果返回值，取决于需求来编写代码逻辑

​ 2) 比较器排序

TreeSet排序：

 public static void main(String[] args) {
     // 使用TreeSet集合存储字符串元素对象并遍历
     //TreeSet() 构造一个新的，空的树组，根据其元素的自然排序进行排序
     TreeSet<String> set1 = new TreeSet<>();
     /*
         TreeSet中的add方法底层实际上是调用了TreeMap中的put方法
      */
     set1.add("banana");
     set1.add("peach");
     set1.add("apple");
     set1.add("watermelon");
     set1.add("banana");
     set1.add("apple");
     set1.add("cherry");
     System.out.println(set1);
     //[apple, banana, cherry, peach, watermelon]
 }

Map【接口】

HashMap

概述：

• 存储数据采用的哈希表结构，允许使用null键和null值，与HashSet一样，元素的存取顺序不能保证一致。
• 所有的key构成的集合是Set：无序的、不可重复的。所以，key所在的类要重写：equals()和hashCode()
• 所有的value构成的集合是Collection：无序的、可以重复的。所以，value所在的类要重写：equals()
• 一个key-value构成一个entry
• 所有的entry构成的集合是Set:无序的、不可重复的

public static void main(String[] args) {
    //借助Map子类HashMap来创建对象
    Map<Integer, String> map1 = new HashMap<>();
    //String put(Integer key,String value) // 返回被覆盖的旧值
    map1.put(1001, "张三");
    map1.put(1002, "李四");
    map1.put(1001, "王五");
    map1.put(1003, "赵六");
    map1.put(1004, "王二麻");
    map1.put(1005, "王林");
    System.out.println("map1: " + map1);
    //map1: {1001=王五, 1002=李四, 1003=赵六, 1004=王二麻, 1005=王林}
    
    System.out.println("-----------------");
    // V get(Object key) 根据键获取值
    System.out.println(map1.get(1005));//王林
    System.out.println("map1: " + map1);
    //map1: {1001=王五, 1002=李四, 1003=赵六, 1004=王二麻, 1005=王林}
    
    System.out.println("-----------------");
    // Set<K> keySet() 将所有的键拿出来放到一个Set集合中
    Set<Integer> keys = map1.keySet();
    for (Integer key : keys) {
        System.out.println(key);//
    }
    //1001 1002 1003 1004 1005
    System.out.println("-----------------");
    
    // Collection<V> values() 将所有的值拿出来放到一个Collection集合中
    Collection<String> values = map1.values();
    for (String value : values) {
        System.out.println(value);//
    }
    //王五 李四 赵六 王二麻 王林
    System.out.println("------------------");
    // Set<Map.Entry<K,V>> entrySet()  将每个键值对拿出来放入到Set集合中
    // map集合遍历方式1：一次获取所有的键值对，依次遍历得到每个键值对的键和值
    Set<Map.Entry<Integer, String>> entries = map1.entrySet();
    for (Map.Entry<Integer, String> entry : entries) {
        // entry -  键值对
        Integer key = entry.getKey();
        String value = entry.getValue();
        System.out.println(key + "-" + value);
    }
    //1001-王五 1002-李四 1003-赵六 1004-王二麻 1005-王林
    System.out.println("------------------");
    // map集合遍历方式2：先获取所有的键，遍历键，根据键得到对应的值
    for (Integer key : keys) {
        // 根据键获取值
        String value = map1.get(key);
        System.out.println(key + "-" + value);
    }
    //1001-王五 1002-李四 1003-赵六 1004-王二麻 1005-王林
    System.out.println("------------------");
}

LinkedHashMap

LinkedHashMap是HashMap的子类：底层数据结构是哈希表【唯一性】和双链表【有序】

public static void main(String[] args) {
    LinkedHashMap<Student3, String> map1 = new LinkedHashMap<>();
    map1.put(new Student3("张三", 18), "打游戏");
    map1.put(new Student3("李四", 16), "看动漫");
    map1.put(new Student3("王五", 18), "看电影");
    map1.put(new Student3("赵六", 17), "看书");
    map1.put(new Student3("钱七", 14), "看美女");
    Set<Map.Entry<Student3, String>> entries = map1.entrySet();
    for (Map.Entry<Student3, String> entry : entries) {
        Student3 key = entry.getKey();
        String value = entry.getValue();
        System.out.println(key + "-" + value);
    }
    /*Student3{name='张三', age=18}-打游戏
      Student3{name='李四', age=16}-看动漫
      Student3{name='王五', age=18}-看电影
      Student3{name='赵六', age=17}-看书
      Student3{name='钱七', age=14}-看美女
    */
}

TreeMap

TreeMap中的自然排序和比较器排序都是针对键来说的,可以保证所有的 Key-Value 对处于有序状态。

public static void main(String[] args) {
    TreeMap<String, String> map1 = new TreeMap<>();
    map1.put("banana", "3");
    map1.put("apple", "4");
    map1.put("peach", "6");
    map1.put("apple", "3");
    map1.put("cherry", "19");
    Set<Map.Entry<String, String>> entries = map1.entrySet();
    for (Map.Entry<String, String> entry : entries) {
        String key = entry.getKey();
        String value = entry.getValue();
        System.out.println(key + "-" + value);
    }
    /*
    apple-3
    banana-3
    cherry-19
	peach-6
    */
}