Java基础_6 集合框架

1.集合框架

多个元素组成一个单元的对象，在面向对象的编程语言中，数据都是通过对象携带的；

存储多个对象：

1. 数组

2. 集合Collection（抽象类，没有下标）

   1. List：对象有序(取的顺序和存在数组中的位置有序)和重复的

      1. Arraylist（数组列表）：有下标、底层实现为数组，查询快、增删慢

      list.add(new String("abc"));	//添加复用类型
      list.add(11);					//添加基本数据类型
      list.remove("abc");				//此“abc”在常量区，new的在堆区。通过equals()对对应的内容进行比较
      System.out.println(list.get(0));//通过索引获取指定位置元素
      list.clear();                   //清空集合
      list.addAll(list2);				//添加一个集合
      Object obj[] = list.toArray();  //List遍历方式之一：转换为数组
      for(int i=0;i<obj.length();i++){
          System.out.print(obj[i]);
      }
      System.out.println(list.contains("abc"));//判断是否包含某个元素
      

      2. LinkedList（数组链表）

         1. 底层实现为链表，查询慢，增删快
         2. 提供了大量的集合首尾操作方法：

            void addFirst(E e);
            void addLast(E e);
            E removeFirst();
            E removeLast();
            E getFirst();
            E getLast();
            E pop();	//弹出，删除集合中第一个元素
            void push(E e);	//推入
         

   2. Iterator：一个接口，专门用于遍历集合，每种集合都实现了不同的遍历方式，调用即可。

       1. 重要方法：
          1. hasNext()：是否有下一个元素
          2. next()：返回下一个元素
      

      import java.util.Iterator;		//头文件
      ArrayList list =new ArrayList();//创建数组
      list.add(1);
      list.add(2);
      list.add(3);
      Iterator it = list.iterator();	//得到iterator对象
      while(it.hasNext()) {			//判断是否有下一个元素
      System.out.println(it.next());
      }
      

   3. HashSet(哈希集)：没有下标、对象无序（取的顺序和存在数组中的位置无序）和不可重复（没有重复值）

           import java.util.HashSet;
      HashSet set = new HashSet();
           set.add("abc");
           set.add(new String("abc"));
           set.add(1);
           set.add(1);
           System.out.println(set.size());	//size输出为2
           ```
      
           **注意：**HashSet使用成员对象来计算hash值，对于两个对象来说hash值可能相同，所以equals()方法用来判断对象的相等性，若相等，则用接在后面链表存储
      
      
      
      

3. Map：存储具有一一对应的键值对（K-V）：例如：身份证号–人

   1. HashMap：基于哈希表的Map实现类，一个Key对应一个Value，允许使用null键和null值

   2. put解释：put通过对键值（key）使用HashCode算出哈希值，再在哈希表中保存value

   3. 冲突处理

      1. 键值（key）相同的值（value）覆盖掉
      2. 键值（key）不同，但算出的hashCode相同，则用链表连接

      **总结：**HashMap底层实现为数组+链表（JDK1.8之前）

   HashMap map = new HashMap();	//得到HashMap对象
   map.put("李华", "李花");		//往map中添加键值对（任意类型），若键值(key)重复则覆盖之前value
   map.remove(1);					//通过键值删除对应的值
   System.out.println(map.size()); //map中有多少键值对（key）
   System.out.println(map.get("李华"));	//通过key键找到对应value
   Iterator it = map.keySet().iterator();	//转换为Iterator对象进行遍历
   while(it.hasNext()) {			//hasNext()判断是否有next
      	Object key = it.next();		//获取next
      	System.out.print("键为："+key+" ");
      	System.out.print("值为："+map.get(key));
      	System.out.println();
   }
   

   遍历hashMap的第二种方法

   1. Entry类型：键值对关系对象

   Map<String, String> map = new HashMap<String, String>(); 
   map.put("1", "a");
   map.put("2", "b");
   map.put("3", "c");
   map.put("4", "d");
   //entrySet获取所有键值关系对象的集合
   Set<Entry<String, String>> A = map.entrySet();	//返回值是一个关系的集合
   Iterator<Entry<String, String>> IA = A.iterator();	//将集合转换为迭代器
   //打印遍历
   while(IA.hasNext()) {
   	Entry<String, String> entry = IA.next();	//返回值为一个关系对象
   	String key = entry.getKey();	//利用Entry的getKey与getValue方法获得键值对的值
   	String value = entry.getValue();
   	System.out.println(key+":"+value);
   }
   

   1. get解释：方法与put一致，冲突处理：键值相同则通过equles进行匹配

   2. HashTable：线程安全

Properties属性集

1. 定义

   • Properties本质上是一个Map集合（实现了Map接口）

     class Properties extends HashTable implements Map
     

   • Properties是一个持久的属性集：即具有自己写数据到文件的方法（告诉写入哪个文件）

   • Properties没有泛型：固定是<String,String>

2. 特有方法

   • 功能和Map中的get一样

     public String getProperty(String key)
     

   • 功能和Map中的put一样

     public Object setProperty(String key,String value)
     

   • 功能和Map中的keySet一样

     public Set<String> stringPropertyNames()
     

3. Properties具有持久化到文件的功能

   1. store：保存数据到文件

      Properties.store(new FileWriter("文件名.Properties"),备注)	//备注可不写
      

   2. load：从文件中加载数据

      Properties.load(new FileReader("文件名.Properties"))
      

      如在数据库连接时，存储驱动、url地址、用户名、密码

2.增强for循环

1. 格式

   for(数据类型 变量名:数组集合){
   	system.out.println(变量名);
   }
   

2. 例子

   • 数组遍历

     int [] a = {1,2,3,4,5,6};
     for(int num : a){
     	system.out.println(num);
     }
     

   • 集合遍历

     Collection<String> names = new ArrayList<String>();	//多态获取数组列表
     name.add("李华");
     name.add("小米");
     name.add("红红");
     for(String name : names){
         system.out.println(name);
     }
     

3. 注意：底层使用的还是迭代器（Iterator）

3.泛型

1. 定义

   • 不确定类型

     ArrayList<E> a1 = new ArrayList<E>();
     

2. 泛型的好处

   • 避免类型强制转换的麻烦

3.泛型方法

• 格式：

  public 返回类型 方法名（T t）

  例子：

  public <T> void show(T t){	//当调用此方法时确定T类型
  	system.out.println(t);
  }
  show("anc")	//调用时确定T类型
  

4.泛型接口

1. 格式

   • 当实现类实现接口时，确定

     public interface MyInterface<E>{	//定义泛型接口
     	public abstract void show(E e);
     }
     
     class MyClass implements MyInterface<String>{	//实现泛型接口
     	public void show(String e){	//重写抽象方法
     		......
     	};
     }
     

   • 实现类实现接口时，不确定，并直接继承泛型

     public interface MyInterface<E>{	//定义泛型接口
     	public abstract void show(E e);
     }
     
     class MyClass<E> implements MyInterface<String>{	//继承泛型接口
     	public void show(E e){	//重写抽象方法
     		......
     	};
     }
     

     注：这个实现类创建对象时确定泛型

2. 泛型通配符（？）

   • <？ extends Animal>：表示一种泛型，这个泛型必须继承了Animal
   • <? super Animal>：表示一种泛型，这个泛型必须是Animal的父类