集合的使用，嘿嘿

集合

概述：

面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，Java就提供了集合类。

数组和集合都是容器，它们两者的区别：

	长度不同	内容不同	类型不同
数组	长度固定	存储相同的数据类型	数组可以存储基本数据类型和引用数据类型
集合	长度不固定	可以存储不同的数据类型	集合只能才能出引用类型

目前我们所学的有两种容器可以用来存储数据

1.数组：可以存对象，但是长度固定，且只能存单一对象

2.StringBuffer(StringBuffer)：只能存字符串

显然这两种容器不能满足我们的要求，所以java提供了集合这一概念

* ArrayList
*     特有方法：
*         public int indexOf(Object o)  返回此列表中首次出现的指定元素的索引
*         public int lastIndexOf(Object o) 返回此列表中最后一次出现的指定元素的索引
*         public Object[] toArray()  将集合转换为数组
*
*     集合---数组：toArray()
*     数组---集合：Arrays类 中的asList()
    
    public class ArrayListDemo {


    public static void main(String[] args) {
        //创建集合对象
        ArrayList list = new ArrayList();
        list.add("Hello");
        list.add("java");
        list.add("java");
        list.add("World");
        list.add("java");

        int index = list.indexOf("java");
        System.out.println("indexOf:" + index);

        int lastIndex = list.lastIndexOf("java");
        System.out.println("lastIndexOf:"+lastIndex);

        Object[] objects=list.toArray();
        String s= Arrays.toString(objects);
        System.out.println(s);




    }
}

Collection类：

是集合继承体系结构中的根节点

• Collection类：是集合继承体系结构中的根节点
  *
• 成员方法：
• 添加功能
• 1.Boolean add(Object o):添加元素
• 2.Boolean addAll(Collection c):添加集合元素
• 删除功能
• 1.boolean remove(Object o):删除指定元素
• 2.boolean remove(Collection c):删除指定集合中的元素
• 3.void clear():删除所有元素
• 判断功能
• 1.boolean contains(Object o)：判断是否包含指定元素
• 2.Boolean containsAll(collection c):判断集合中是否包含指定集合中的所有元素
• 3.Boolean isEmpty():判断集合是否为空
• 长度功能
• int size():获取集合中

/**
 * Collection类：是集合继承体系结构中的根节点，集合表示一组对象的容器，这些对象有重复的，有不重复的，有有序的，有无序的
 *
 *
 *    成员方法：
 *     添加功能
 *        1.Boolean add(Object o):添加元素
 *        2.Boolean addAll(Collection c):添加集合元素
 *     删除功能
 *        1.boolean remove(Object o):删除指定元素
 *        2.boolean remove(Collection c):删除指定集合中的元素
 *        3.void clear():删除所有元素
 *     判断功能
 *        1.boolean contains(Object o)：判断是否包含指定元素
 *        2.Boolean containsAll(collection c):判断集合中是否包含指定集合中的所有元素
 *        3.Boolean isEmpty():判断集合是否为空
 *     长度功能
 *       int size():获取集合中
 */
public class CollectionDemo {
    public static void main(String[] args) {
        //创建集合对象
        Collection c = new ArrayList();

        //添加元素
        c.add("hello");
        c.add("world");
        c.add("java");
        System.out.println(c);//重写toString方法
//        c.addAll(c);
//        System.out.println(c);

        //删除元素
//        c.clear();
//        System.out.println(c);
//        c.remove("hello");
//        System.out.println(c);

        //判断元素

        System.out.println("contains:"+c.contains("world"));
        System.out.println("isEmpty:"+c.isEmpty());
//        c.clear();
//        System.out.println("isEmpty:"+c.isEmpty());

        //获取集合长度
        System.out.println("size:"+c.size());




    }
}

迭代器Iterator

/**
 * 迭代器Iterator
 */
public class IteratorDemo {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("Hello");
        list.add("World");
        list.add("java");

        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            String s = (String) iterator.next();
            System.out.println(s);


    }
        Object[] ob = list.toArray();
        for (int i = 0; i < ob.length; i++) {
            System.out.println(ob[i]);
        }


}


}

List接口

​ •有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。

​ •与 set 不同，列表通常允许重复的元素。

/**
 * List接口：是一个元素有序的并且可以允许元素重复的集合。
 *     List特有方法：
 *           添加功能
 *           add(int index,E element):添加元素到指定索引位置
 *           addAll(int index,Collection c):将集合添加到指定索引位置
 *           获取功能
 *           Object get(int index):返回指定索引位置的元素
 *           修改功能
 *           E set(int index,E element):将指定元素替换集合中指定索引位置的元素,将被替换的元素返回
 *           截取功能
 *           List subList(int fromIndex,int toIndex):从指定索引位置开始，截取到指定索引位置结束
 *                                                    将截取内容作为新的集合返回，原集合数据不变
 *           删除功能
 *           E remove(int index):删除指定索引位置的元素
 */
public class ListDemo {
    public static void main(String[] args) {
        List list = new ArrayList();
        //添加元素
        list.add("Hello");
        list.add("World");
        list.add("java");
        System.out.println(list);
        list.add(1, "aaa");
        System.out.println(list);




        List list2 = new ArrayList();
        list2.add("你好");
        list2.add("世界");
        list2.add("爪洼");
        list.add(2, list2);
        System.out.println(list);


       //删除
        list.remove(2);
        System.out.println(list);

        //替换
        list.set(2, "aaa");
        System.out.println(list);



    }
}

LinkedList

•底层数据结构是链表，查询慢，增删快

​ •线程不安全，效率高

/**
 * LinkedList :
 *      添加功能
 *       void addFirst(E e)
 *           将指定元素插入此列表的开头。
 *       void addLast(E e)
 *           将指定元素添加到此列表的结尾。
 *      获取类型：
 *        E getFirst()  获取该集合第一个元素
 *        E getLast()   获取该集合的最后一个元素
 *      删除功能：
 *         E removeFirst()  删除该集合第一个元素
 *         E removeLast()    删除该集合最后一个元素
 *
 *
 */
public class LinkedListDemo {
    public static void main(String[] args) {
        //创建集合对象
        LinkedList<Integer> linkedList = new LinkedList<>();
        //添加元素
        linkedList.add(10);
        linkedList.add(20);
        linkedList.add(30);
        linkedList.add(40);
        System.out.println(linkedList);

        linkedList.addFirst(60);
        System.out.println("assFirst:"+linkedList);
        linkedList.addLast(1);
        System.out.println("addLast:" + linkedList);

        //获取功能
        System.out.println("getFirst:" + linkedList.getFirst());
        System.out.println("getLast:" + linkedList.getLast());

        //删除功能
        System.out.println("removeFirst:"+linkedList.removeFirst());
        System.out.println("removeLast:"+linkedList.removeLast());

    }
}

常见的数据结构

栈：

​ 特点：先进后出

队列：

​ 特点：先进先出

数组：

​ 特点：查询快，增删慢

链表：

​ 特点：查询慢，增删快

泛型

是一种吧明确数据类型的工作推迟到创建对象或调用方法的时候才去明确的一种特殊数据类型

好处：把运行是可能出现的异常提前到编译时。提高程序的健壮性

泛型类

​ 权限修饰符 class 类名<泛型类型，……>

泛型方法

​ public <泛型类型> 返回类型 方法名（泛型类型 ，）

泛型接口

​ 把泛型定义在接口上

​ 格式:public interface 接口名<泛型类型1…>

public class FanXing {
    public static void main(String[] args) {
        ArrayList<String> arr=new ArrayList<String>();
        arr.add("hello");
        arr.add("world");
        arr.add("java");
        Iterator<String> sc=arr.iterator();
        while (sc.hasNext()){
            String st=sc.next();
            System.out.println(st);
        }
    }
}

Set集合

Set接口概述:

一个不包含重复元素的集合。它是无序的（存入顺序和取出顺序不一致）相对于List集合来说的。

并且List集合是有序的(指存入顺序和取出顺序一致)

HashSet类概述:

一个实现Set接口的类，他不能保证迭代顺序，特别是它不能保证在一段时间内的迭代顺序。

/**
 * Collection
 *       list:有序，可以重复
 *       set：无序，不可以重复
 *
 *       HashSet：底层由哈希表实现，它不保证set的迭代顺序：特别是它不保证顺序恒久不变
 *
 *       注意事项：Set作为集合，虽然它是无序的，但是它肯定有自己的存储顺序，当你添加和遍历的顺序一致时，
 *                并不代表它是有序的，多添加几个元素，多执行几次就会出现不同的情况
 *
 *                add方法去重依赖hashCode()和equals()
 */
public class SetDemo {
    public static void main(String[] args) {
        //创建集合对象
        HashSet<String> set = new HashSet<>();
        //添加元素
        set.add("hello");
        set.add("java");
        set.add("World");
        set.add("python");
        System.out.println(set);

        //遍历set集合
        for (String s : set) {
            System.out.println(s);
        }
        
        

TreeSet:

/**
 * TreeSet:能够对元素按照某种规则进行排序
 *     1.自然排序---无参构造
 *     2.比较器排序---有参构造：Comparator接口
 *
 *     TreeSet存储特点：唯一和排序
 *
 *     通过add源码
 *          TreeSet的排序过程是依赖于Comparator方法,而这个方法是定义在
 */
public class TreeSetDemo {
    public static void main(String[] args) {

        TreeSet<Integer> treeSet = new TreeSet<>();

        treeSet.add(10);
        treeSet.add(4);
        treeSet.add(19);
        treeSet.add(12);
        treeSet.add(15);

        for (int num : treeSet) {
            System.out.println(num);
        }

    }
}

Map

概述：将键映射到值的对象，一个映射不能包含重复的键，每个键最多只能映射一个值。

	Map	Collection
区别1	Map是双列的	单列
区别2	Map的键是唯一的	只由set体系才是唯一的
区别3	Map集合数据结构只针对键有效，和值无关	数据结构针对元素有效

比较：

在Map中，元素都是成对出现的，键唯一，值允许重复，我们记忆为夫妻对

在Collection中，元素都是单独出现的，List体系是可重复的，Set体系是唯一的。我们记忆为单身对。

/**
 * Map集合
 *   通过API 我们学习到Map集合最大的特点：它是用来存储键值对元素的
 *         学号1    学生1
 *         学号2    学生2
 *         学号2    学生3 （错误）
 *         学号3    学生3 （正确）
 *   特点：
 *      将键映射到值的对象，一个映射不能包含重复的键，并且每个键只能映射到一个值
 *
 *   Map集合与Collection集合的区别：
 *     1.Map集合存储的元素是成对出现的
 *     2.Collection集合存储的元素是单独出现的，并且，set是唯一的，list是可重复的
 *
 *     注意事项：
 *        Map集合的数据结构是针对键有效，跟值无关
 *     主要方法：
 *        1.添加功能
 *        V put(K key,V value)：将指定的值与此映射中的指定键关联（可选操作）。
 *        2.删除功能
 *        void clear()：删除所有映射关系
 *        V remove(Object key)：如果存在一个键的映射关系，则将其从此映射中移除
 *        3.获取功能
 *        Set<Map.Entry<K,V>> entrySet()：返回此映射中包含的映射关系的 Set 视图。
 *        V get(Object key)：返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
 *        Set<K> keySet()：返回此映射中包含的键的 Set 视图。
 *        Collection<V> values()：返回此映射中包含的值的 Collection 视图
 *        4.判断功能
 *        boolean containsKey(Object key)：如果此映射包含指定键的映射关系，则返回 true。
 *        boolean containsValue(Object value)：如果此映射将一个或多个键映射到指定值，则返回 true。
 *        boolean equals(Object o)：比较指定的对象与此映射是否相等。
 *        boolean isEmpty():如果此映射未包含键-值映射关系，则返回 true。
 *        5.长度功能
 *        int size()：返回此映射中的键-值映射关系数
 *
 */
public class MapDemo {
    public static void main(String[] args) {
        //创建Map集合对象
        Map<String, String> map = new HashMap<>();
        //添加元素
        //V put(K key,V value)：将指定的值与此映射中的指定键关联（可选操作）。
        map.put("阿里巴巴", "马云");
        map.put("腾讯", "马化腾");
        map.put("字节跳动", "张一鸣");
        map.put("网易", "丁磊");
        String s=map.put("阿里巴巴", "赵童");
        System.out.println("put:"+s);

        String s1 = map.remove("阿里巴巴");

        String s2 = map.get("字节跳动");
        System.out.println(s2);

        Set<String> keySet=map.keySet();
        for (String s3 : keySet) {
            System.out.println(s3);
        }
        // Collection<V> values()：返回此映射中包含的值的 Collection 视图
        Collection<String> keySet2 = map.values();
        for (String s4 : keySet2) {
            System.out.println(s4);
        }

        System.out.println("containsKey:" +map.containsKey("阿里巴巴"));
        System.out.println("containsValues:"+map.containsValue("张一鸣"));



        System.out.println(map);
    }
}

HashMap

/**
 * HashMap<String,String></String,String>
 */
public class MapDemo2 {
    public static void main(String[] args) {
        HashMap<String,String> hm=new HashMap<String, String>();
        hm.put("语文","YuWen");
        hm.put("数学","ShuXue");
        hm.put("英语","English");
        hm.put("体育","TiYu");
        //遍历
        //方式1
        Set<String> se=hm.keySet();
        for (String keys:se) {
            String value=hm.get(keys);
            System.out.println(keys+"------"+value);
        }
        //方式2
        Set<Map.Entry<String,String>> ss=hm.entrySet();
        for (Map.Entry<String,String> en:ss) {
            String key= en.getKey();
            String value=en.getValue();
            System.out.println(key+"--------"+value);
        }
    }
}

LinkedHashMap

/**
 * LinkedHashMap
 *    概述：是HashMap的子类，底层数据就能够由链表和哈希表组成
 *         链表保证了元素的有序（元素的插入和取出顺序一致）
 *         由哈希表保证了元素的唯一性
 */
public class LinkedHashMapDemo {
    public static void main(String[] args) {
        LinkedHashMap<String, String> ln = new LinkedHashMap<>();

        ln.put("12345", "hello");
        ln.put("22345", "world");
        ln.put("32345", "java");
        ln.put("12345", "hellohello");
        ln.put("32345", "love");

        Set<String> keys = ln.keySet();
        for (String key : keys) {
            System.out.println(key+"  "+ln.get(key));
        }


    }
}

TreeMap

• 键是红黑数，可以保证键的有序和唯一性。

/**
 * 
 */
public class TreeMapTest {
    public static void main(String[] args) {
        TreeMap<Student, String> map = new TreeMap<>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num = s1.getName().length() - s2.getName().length();
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                int num3 = num2 == 0 ? (s1.getAge() - s2.getAge()) : num2;

                return num3;
            }
        });

        map.put(new Student("唐康", 19),"嘿嘿嘿");
        map.put(new Student("赵童", 18),"啦啦啦");
        map.put(new Student("屈波", 20),"哈哈哈");

        Set<Student> keys = map.keySet();
        for (Student key : keys) {
            System.out.println(key+"  "+ map.get(key));
        }

    }
}