java学习日记 集合框架

Posted 2020-10-04

集合框架 

有两大接口  一个是 Collection （类集 ）与Map （映射）；

collection 下有两大接口  一个是List （列表） 另一个是Set（集合）

List （列表）：ArrayList 基于数组实现的动态列表    动态数组 ；

　　　　　　　LinkedList 基于链表实现的列表      双向循环链表

　　　　　　Vector 向量   ------》stack栈           与线程相关；

Set （集合） ：TreeSet       通过树实现的集合  有序集合

　　　　　　HashSet     通过hash桶实现的集合 无序集合  ----->LinkedHashSet  基于链式存储结构的无序集合；

Map （映射） Hashtable hash表

　　　　　　HashMap 通过hash桶实现的映射 无序映射

　　　　　　TreeMap 通过树实现的映射      有序映射

 

Map （映射 ） 就是将任意个对象起一个别名   

HashMap数据的特征 有名无序：每一个数据存储在hash桶中有他们的名字但是顺序不确定，即放入map数据和输出时的顺序可能不一样；

通过右边的图片不难看出，内部存储是无序的。　　　　　　　　　　　　　　

关于<string，string >的含义：就是泛型；给数据一个约定大家都往里边存string

类型的数据，后边的<>是可以省略不用写的，默认和前边的一样。

在代码中，大家也看到了我们用put方法放入数据。方法里两个参数：第一个为key  用来给数据起个名字，特有的因为重名就会被覆盖他代表的数据。第二个为value，代表对象（数据）。他俩在一起叫做 键值对

我们可以通过key值获取对应的value值；get（key）方法 ；

　　　　　　　　获取map中数据的多少用 size（）方法　

　　　　　　　　清空map内数据，但是map保留的用的方法是 clear（）； 　

map是可以合并的

根据上图我们可以看出相应的用法；

private static void maptest1()
	{
		Map<String,String> map=new HashMap<>();
		map.put("name", "王徽");
		map.put("id", "110");
		map.put("class", "no.1");
		map.put("number", "250");
		Map<String,String> map2=new HashMap<>();
		map2.put("1", "123");
		map2.put("2", "250");
		System.out.println("map"+map);
		System.out.println("map2"+map2);
		int size=map.size();
		System.out.println("size :"+size);
		String id=map.get("id").toString();
		System.out.println("id :"+id);
		map.putAll(map2);
		System.out.println("map合并map2后 "+map);
		
	}

　　删除用的方法 remove（key）；在java1.7之前key不存在会报错，现在不会了

　　替换的方法 put；

 

影响hashMap性能的因素：

一个是：初始内存 （初始16）

另一个数：加载因子（初始0.75）  这个是从时间和空间上决定的，不做修改

hashmap的机制是 内部存储说起。他是有hash桶进行存储，初始化16个当到达12（16*0.75）个时 ，在加就要hash内部重构进行扩容。容量翻倍增长。

所以机智的我们这样调用构造子的时候进行初始化他的初始内存数  我们需要的/0.75+1  这样就减少了内存虚耗；

 

List列表 ；

列表的创建和元素的添加与获取 基础方法演示；、

我们可以看到数据  无名有序；

元素插入 add（）方法 有两个，一个是顺序插入add（value） 一个参数 代表数据 ，另一个时 指定插入  两个参数add（index，value），index便是要插入的下标，注意当插到末尾的时候 适合add（value）一样的效果；

元素替换的方法 set（index，value）；index要替换的下标，value替换后的内容；

列表空判断 方法 isEmpty（ ）  返回的是Boolean值；

获取长度的方法是 size（）  ；

元素的删除 remove（）方法  这个有两个  ，一个是内容，一个是索引，按照这两个删除，但是当列表是int类型时 ，内容和索引都是int java就以索引优先进行删除。

List转换成数组：

、

	private static void listtest1()
	{
		List<Integer> date=new ArrayList<>();
		System.out.println(date);
		date.add(1);
		date.add(2);
		date.add(3);
		date.add(4);
		System.out.println(date);
		int a=date.get(2);
		System.out.println(a);
		date.set(2, 100);
		System.out.println(date);
		date.remove(2);
		System.out.println(date);
		Integer arr[]=new Integer[date.size()];
		date.toArray(arr);
		for(Integer b:arr)
		{
			System.out.println(b);
		}
	}

　　

迭代器（迭代接口）

private static void iteratorTest()
    {
        List<Integer> date=new ArrayList<>();
        System.out.println(date);
        date.add(1);
        date.add(2);
        date.add(3);
        date.add(4);
        date.add(5);
        date.add(6);
        date.add(7);
        int size=date.size();
        /**
         * 获取迭代器
         * hasNext();判断是否含有数据；返回的是boolean值，
         * Next() 获取当前值，
         */
        Iterator<Integer> iter=date.iterator();
        while(iter.hasNext())
        {
            System.out.println(iter.next());
        }
        
    }

迭代器

存在List专用迭代器 ；

private static void listIteratorTest()
    {
        List<Integer> date=new ArrayList<>();
        System.out.println(date);
        date.add(1);
        date.add(2);
        date.add(3);
        date.add(4);
        date.add(5);
        date.add(4);
        date.add(4);
        int size=date.size();
        ListIterator<Integer> iter=date.listIterator();
        System.out.println("----正序迭代------");
        while(iter.hasNext())
        {
            System.out.println(iter.nextIndex()+":"+iter.next());
        }
        /**
         * 元素修改set
         * 和删除remove;
         * 注意remove删除后 迭代就断了 ，我们去最后验证删除
         */
        date.set(3, 100);
        System.out.println("----倒序迭代------");
        while(iter.hasPrevious())
        {
            System.out.println(iter.previousIndex()+":"+iter.previous());
        }
        /**
         * 从指定位置index截断开始迭代，注意阶段后只能正序迭代一次 ，然后就恢复啦
         * 据我了解应该是相当于一个指针在走，你走到头就走不动啦，连续迭代两次统一方向，第二次没结果
         * 然后从截断开始迭代到头，然后再往反方向走，就又可以全部走一遍并走到头。
         */
        ListIterator<Integer> iter2=date.listIterator(3);
        System.out.println("----正序迭代------");
        while(iter2.hasNext())
        {
            System.out.println(iter2.nextIndex()+":"+iter2.next());
        }
        System.out.println("----倒序迭代------");
        while(iter2.hasPrevious())
        {
            System.out.println(iter2.previousIndex()+":"+iter2.previous());
        }
        while(iter.hasNext())
        {
            if(iter.next()==4)
                iter.remove();
        }
        /**
         * 删除后 我们只能打印date，因为listiterator被破坏了、
         * 打印出来后我们发现是4的都被删除啦；
         */
        System.out.println(date);
    }

ListIterator

影响ArrayList性能的因素：初始容量 ，默认值为10

和我们解决hashmap的方法一样在实例化的时候 ，调用构造子的时候 初始上我们需要的大小

他的扩容倍数是1.5.满了就扩容。

Vector初始容量为10，他的扩容倍数为2倍；