java的集合, 键值对

package JavaArrayDemon;

import java.text.ParseException;
import java.util.*;


基本数据类型: boolean，char，byte，short，int，long，float，double
封装类类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double

* java集合框架：
*   Collection：存放的是单一值
*       特点：
*           1、可以存放不同类型的数据，而数组只能存放固定类型的数据
*           2、当使用arraylist子类实现的时候，初始化的长度是10，当长度不够的时候会自动进行扩容操作
*       api方法：
*           增加数据的方法
*           add：要求必须传入的参数是Object对象，因此当写入基本数据类型的时候，包含了自动拆箱和自动装箱的过程
*           addAll:添加另一个集合的元素到此集合中
*
*           删除数据的方法
*           clear:只是清空集合中的元素，但是此集合对象并没有被回收
*           remove:删除指定元素
*           removeAll：删除集合元素
*
*           查询数据的方法
*           contains:判断集合中是否包含指定的元素值
*           containsAll:判断此集合中是否包含另一个集合
*           isEmpty:判断集合是否等于空
*           retainAll:若集合中拥有另一个集合的所有元素，返回true，否则返回false
*           size:返回当前集合的大小
*
*           //集合转数组的操作
*           toArray:将集合转换成数组


 *   1、set中存放的是无序，唯一的数据 set对应k 键
 *   2、set不可以通过下标获取对应位置的元素的值，因为无序的特点
 *   3、使用treeset底层的实现是treemap,利用红黑树来进行实现
 *   4、设置元素的时候，如果是自定义对象，会查找对象中的equals和hashcode的方法，如果没有，比较的是地址
 *   5、树中的元素是要默认进行排序操作的，如果是基本数据类型，自动比较，如果是引用类型的话，需要自定义比较器
 *       比较器分类：
 *         内部比较器
 *               定义在元素的类中，通过实现comparable接口来进行实现
 *         外部比较器
 *               定义在当前类中，通过实现comparator接口来实现，但是要将该比较器传递到集合中
 *         注意：外部比较器可以定义成一个工具类，此时所有需要比较的规则如果一致的话，可以复用，而
 *               内部比较器只有在存储当前对象的时候才可以使用
 *               如果两者同时存在，使用外部比较器
 *               当使用比较器的时候，不会调用equals方法

public class MainDemo {
    public static void main(String[] args) throws ParseException {
        LinkedList<String> linkedList = new LinkedList();
        List<String> arrayList = new ArrayList();
        linkedList.add("123");
        linkedList.add("abc");
        linkedList.add("efg");
        linkedList.addFirst("123456");
        linkedList.addLast("5674");
        linkedList.set(2,"sbsb"); //替换第三个元素

        linkedList.offer("sasas"); //末尾
        System.out.println(linkedList);
        System.out.println("---------linkedList--------------");
        System.out.println(linkedList.toArray()[0]);
        System.out.println("----------linkedList-------------");
        System.out.println(linkedList.get(2));

        //arrayList.set(0,"sbsbsb");
        arrayList.add("123");
        arrayList.add("456");
        arrayList.add("777");
        arrayList.set(1,"888"); //替换第二个元素
        System.out.println("-----------arrayList------------");
        System.out.println(arrayList);
        System.out.println(arrayList.get(1));

        Set set = new HashSet();
        set.add("123");
        set.add(1);
        set.add(true);
        set.add("123");
        System.out.println("-----------HashSet------------");
        System.out.println(set);

        System.out.println("-----------TreeSet------------");
        TreeSet treeSet = new TreeSet();
        treeSet.add(34);
        treeSet.add(1);
        treeSet.add(65);
        System.out.println(treeSet.ceiling(4)); //从集合中返回指定元素的相等或最接近的最大元素，如果没有，则返回null。
        System.out.println(treeSet);
        HashSet hashSet = new HashSet();
        hashSet.add(new Person("zhangsan",12));
        hashSet.add(new Person("zhangsan",12));
        hashSet.add(new Person("lisi",13));
        System.out.println(hashSet);
    }
}

结果 :

[123456, 123, sbsb, efg, 5674, sasas]
---------linkedList--------------
123456
----------linkedList-------------
sbsb
-----------arrayList------------
[123, 888, 777]
888
-----------HashSet------------
[1, 123, true]
-----------TreeSet------------
34
[1, 34, 65]
[Person{name='zhangsan', age=12}, Person{name='lisi', age=13}]

Map的练习

package MapDemon;

import java.util.*;

/**
 * 数组, 链表, 红黑树
 * set:键
 * map存储的是k-v键值对映射的数据  c#中的dictionary , 但是map在java是接口
 *      实现子类：
 *          HashMap：数据+链表(1.7)   数组+链表+红黑树(1.8)
 *          LinkedHashMap：链表
 *          TreeMap:红黑树
 *
 *      基本api操作：
 *          增加：
 *              put（k,v）    添加元素
 *          查找：
 *              isEmpty      判断是否为空
 *              size        返回map的大小
 *              containsKey
 *              containsValue
 *              get
 *          删除：
 *              clear 清空集合中的所有元素
 *              remove:删除指定元素
 *     Map.entry:表示的是K-V组合的一组映射关系，key和value成组出现
 *
 *     hashmap跟hashtable的区别：
 *      1、hashmap线程不安全，效率比较高，hashtable线程安全，效率低
 *      2、hashmap中key和value都可以为空,hashtable不允许为空
 *
 *
 *      hashmap初始值为2的N次幂，
 *          1、方便进行&操作，提高效率，&要比取模运算效率要高
 *              hash & (initCapacity-1)
 *          2、在扩容之后涉及到元素的迁移过程，迁移的时候只需要判断二进制的前一位是0或者是1即可
 *              如果是0，表示新数组和就数组的下标位置不变，如果是1，只需要将索引位置加上旧的数组的长度值即为新数组的下标
 *      1.7源码知识点：  数组+链表
 *          1、默认初始容量
 *          2、加载因子
 *          3、put操作
 *              1、设置值，计算hash
 *              2、扩容操作
 *              3、数据迁移的过程
 *      1.8源码知识点:   数组+链表+红黑树
 */
public class MainDemon {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<String, Integer>();
        map.put("a",1);
        map.put("b",2);
        map.put("c",3);
        map.put("d",4);
        map.put(null,null);
        System.out.println(map); //输出 {null=null, a=1, b=2, c=3, d=4} key = value
        System.out.println(map.isEmpty());
        System.out.println(map.size());
        System.out.println("-------------------------");
        System.out.println(map.containsKey("a"));
        System.out.println(map.containsValue(2));
        System.out.println(map.get("a")); //拿出a对应的值

        //遍历操作
        System.out.println("---------------两种遍历方法--------------");
        Set<String> keys = map.keySet();
        for (String key : keys
             ) {
            System.out.println(key + "=" + map.get(key));
        }

        //遍历操作2
        //只能获取对应的value值，不能根据value来获取key
        Collection<Integer> values = map.values();
        for (Integer i: values
             ) {
            System.out.println(i);
        }
        //Java Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法，可用于迭代 ArrayList 和 HashSet 等集合。
        //Iterator 是 Java 迭代器最简单的实现，ListIterator 是 Collection API 中的接口， 它扩展了 Iterator 接口。
        System.out.println("-----------使用迭代器------------------");
        Set<String> keySet = map.keySet();
        Iterator<String> iterator = keySet.iterator();
        while (iterator.hasNext())
        {
            String key = iterator.next();
            System.out.println(key+"="+map.get(key));
        }

        System.out.println("-----------使用Map.Entry------------------");
        //Map.entry:表示的是K-V组合的一组映射关系，key和value成组出现
        Set<Map.Entry<String, Integer>> entries = map.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator1 = entries.iterator();
        while (iterator1.hasNext())
        {
            Map.Entry<String, Integer> next = iterator1.next();
            System.out.println(next.getKey() + "--" +next.getValue());
        }
    }
    }

结果:

{null=null, a=1, b=2, c=3, d=4}
false
5
-------------------------
true
true
1
---------------两种遍历方法--------------
null=null
a=1
b=2
c=3
d=4
null
1
2
3
4
-----------使用迭代器------------------
null=null
a=1
b=2
c=3
d=4
-----------使用Map.Entry------------------
null--null
a--1
b--2
c--3
d--4

collections和比较器

package mapDemon2;

import java.util.*;

public class mapDemon {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("af");
        list.add("bg");
        list.add("acssf");
        list.add("bdfsdfsd");

        Collections.addAll(list, "dds", "cds", "cg3233");
        System.out.println("-----list本来的顺序----");
        System.out.println(list);

        System.out.println("-----collections的sort, 按照字母的字典顺序排序----");
        Collections.sort(list);
        System.out.println(list);

        System.out.println("-----collections的sort, 传入外部比较器----");
        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                if (o1.length() > o2.length())
                    return 2;
                else if (o1.length() < o2.length())
                    return -2;
                else
                    return 0;
            }
        });

        //二分查找的时候需要先进行排序操作，如果没有排序的话，是找不到指定元素的
        Collections.sort(list);
        System.out.println("-------Collections二分查找--------------");
        System.out.println("键:"+Collections.binarySearch(list,"bg"));

        Collections.fill(list,"sbsb1");
        System.out.println("-------Collections的插入元素--------------");
        /*
         *对Comparetor.compare(o1, o2)方法的返回值，如果返回的值小于零，则不交换两个o1和o2的位置；如果返回的值大于零，则交换o1和o2的位置。
         *注意，不论在compare(o1, o2)中是如何实现的（第一种实现方式是 o1-02, 第二种实现方式是 o2 - o1），都遵循上述原则，即返回值小于零，
         *则交换o1和o2的位置；返回值大于零，则不交换o1和o2的位置。
         *所以，如果采用第一种实现方式，即 o1 - o2, 那么将是升序排序。因为在原始排序中o1在o2的前边，如果o1小于o2，那么o1 - o2小于零，
         *即返回值是小于零，但是小于零是不会交换o1和o2的位置的，所以o1依然排在o2的前边，是升序；如果o1大于o2，那么o1 - o2大于零，
         *即返回值是大于零，大于零是要交换o1和o2的位置的，所以要改变原始排序中o1和o2的位置，那么依然是升序
         *
         * 内部比较器是comparable接口
         * 外部比较器是comparator接口
         * */
        // 匿名内部类
        list.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                if (o1.length() > o2.length())
                    return 1;
                else if (o1.length() < o2.length())
                    return -1;
                else
                    return 0;
            }
        });
        System.out.println("-----外部比较器与匿名内部类结合应用----");
        System.out.println(list);


        System.out.println("--------外部比较器与匿名内部类结合应用的原理--------------");

        Student a = new Student("Ahana", 18);
        Student b = new Student("Babily", 19);

        System.out.println(a.compareTo(b));

        System.out.println("--------外部比较器与匿名内部类结合应用的原理实例--------------");
        Comparator bj = new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Student a1 = ((Student) o1);
                Student a2 = (Student) o2;
                return a1.getAge() - a2.getAge();
            }
        };
        int result = bj.compare(a, b);
        System.out.println(result);
    }
}

结果:

-----list本来的顺序----
[af, bg, acssf, bdfsdfsd, dds, cds, cg3233]
-----collections的sort, 按照字母的字典顺序排序----
[acssf, af, bdfsdfsd, bg, cds, cg3233, dds]
-----collections的sort, 传入外部比较器----
-------Collections二分查找--------------
键:3
-------Collections的插入元素--------------
-----外部比较器与匿名内部类结合应用----
[sbsb1, sbsb1, sbsb1, sbsb1, sbsb1, sbsb1, sbsb1]
--------外部比较器与匿名内部类结合应用的原理--------------
-1
--------外部比较器与匿名内部类结合应用的原理实例--------------
-1