2024-1-29 笔记

**java集合知识点总结**

集合：相当于容器（Container），用于存储多个数据。不同的容器代表不同的数据结构，用于存储和管理具有特定关系的一组数据。

集合框架： 集合框架可以看作是一组容器的集合。JAVA对常用数据结构和算法进行了封装，对外提供了一套设计优良的接口和类。

集合框架的特点：

（1） 集合类本身也是一个对象，是可以存储多个元素的对象 。

（2）基本数据类型必须借助与之对应的Wrapper包装器类。

（3）集合中存放的元素都是Object类型的对象。

（4）集合类的容量可以动态增长。

Collection接口描述set和list集合类型的根接口

**List：**

（1）元素必须按顺序存放

（2）通过索引号标识元素在List中的位置，用户能够使用索引号来访问List 中的元素，索引号从0开始

（3）允许存储任意对象，且允许出现重复的对象或null空对象

ArrayList：

（1）以数组的形式对List接口提供了实现，是容量可动态增长的数组

（2）允许存储任意元素，包括重复对象和null空对象

（3）以索引号方式存取对象

（4）ArrayList是非同步的（unsynchronized），多线程并发访问时不安全

LinkedList：

（1）List接口的实现类，以双向链表的形式存储数据

（2）不支持多线程并发访问

**Set：**

（1）Collection接口的子接口，方法和Collection中的一致。

（2）Set中的元素无顺序，存储的对象不允许重复。

HashSet:

（1）Set接口的实现类，存储的对象无序，且不允许重复

（2）HashSet采用了哈希散列算法存储元素。当需要添加新的对象时，先根据该对象的hashcode()方法确定它在内存中的存放地址，如果该位置上没有其他对象，就直接存储在这个位置上；如果该位置上已经有对象了，就调用equals()方法对两个对象进行比较，相同就不允许添加，不同就以链表的方式散列到该位置其他元素的后面

（3）声明和创建、添加元素、删除、遍历

Set  set  =  new  HashSet();
String  s1  =  "hello";
String  s2  =  new String("world");
String  s3  =  new String("world");
String  s4  =  "java";
 set.add(s1);
 set.add(s2);
 set.add(s3);
 set.add(s4);
 set.remove(s1);
 //采用for循环实现对Set中元素的遍历
Object[] os = set.toArray();
for(int i=0;i<os.length;i++){
    System.out.println(os[i]);    
}
//结果：java
//     world

（4）常用方法：

public boolean add(E e)  给Set中添加一个对象e

public void clear()   删除Set中所有元素

 public Boolean remove(Object o)  删除Set中指定元素o

（5）拓展

**自定义的类**实现哈希算法

举例：

public  class  Employee{
    private int id;
    private String name;
    private double salary;
    …  …
}
//重写hashCode()方法：可自定义算法规则，确保两个对象返回的整型哈希码相同即可
//hashCode方法：返回 set 的哈希码值。
public int hashCode() {
    return (int)(id+name.hashCode()+salary);
}
//重写equals()方法
//equals方法：比较指定对象与此 set 的相等性。
public boolean equals(Object obj){
    if(this == obj)  
    return true;
    if(obj instanceof Employee){//instanceof 判断其左边对象是否为其右边类的实例
         Employee e = (Employee)obj;
        if(e.getId()==id && 
                 e.getSalary()==salary && e.getName().equals(name)){
            return true;    
        }else{
            return false;    
        }
    }else{
        return false;    
    }
}

**Map：**

（1）Map中的元素都是成对出现的，以键值对映射的形式存储和管理数据

（2）采用key——values的，不允许有重复的键，每个键最多对应一个值，即每个对象都有一个唯一的key值，每个key对应一个value ，通过key可以实现对value对象的访问，但value对象允许重复

（3）key和value都为Object对象

（4）常用实现类：HashMap、Hashtable

子接口：SortedMap-->TreeMap(实现类)

Map.Entry接口：

（1）存储键值对的映射关系, 每个Map.Entry对象代表Map中一个特定的键/值对

（2） Map接口提供了entrySet()方法返回所有的映射集合

（3）该接口中提供了方法访问映射关系两端的key与value对象

（4）常用方法：

 getKey()：获取该对象的key值

 getValue()：获取该对象

 setValue()：修改value对象

put(objectkey，objectvalues)增加一个新的值

get(objectkey)查找key上面的值

SetkeySet()将所有的key返回到一个set中

java集合只能保存引用类型的数据，是对象的引用

（5）Map的应用

//添加元素
Map  map  =  new  HashMap();
String  s1 = “hello”;
String  s2 = “world”;
String  s3 = “Hi”;
String  s4 = new String(“java”);
map.put(new Integer(1), s1);
map.put(new Integer(2), s2);
map.put(new Integer(3), s3);
map.put(new Integer(3), s4); //重复的key，结果如何？
//删除元素
 map.remove(1);  //根据key值删除
 map.remove(s2); //根据value对象删除？
//遍历所有key
/*Object[]  keys = map.keySet().toArray();
for(int i=0;i<keys.length;i++){
    System.out.println("key: "+keys[i]);
}*/
Iterator iter1=map.keySet().iterator();
while(iter1.hasNext()){   //迭代器遍历
        System.out.println(iter1.next());
}
//遍历所有value
Iterator iter2=map.values().iterator();
while(iter2.hasNext()){   //迭代器遍历
        System.out.println(iter1.next());
}
//遍历所有映射
Iterator iter3=map. entrySet().iterator();
while(iter3.hasNext()){   //迭代器遍历
      Map.Entry entry = (Map.Entry)iter3.next();
        System.out.println(entry.getKey()+": “
            +entry.getValue());
}
//结果
key: 2
key: 3
=============================
value: world
value: java
=============================
2 : world
3 : java

（6）总结：

当添加新映射时，如果key有重复，会用新的value对象替换原来的key所对应的value。

删除对象时只能根据key值删除，不能根据value删除。

相关方法：

add如果增加重复元素，则增加失败，返回false

contains()  判断是否包含有某个元素

Collectionvalues()  将所有的值返回到一个collection集合中 

set(index，elemetn)  修改指定索引下的元素

遍历集合的方法：

（1）for循环

（2）增强for循环

（3）迭代器

迭代器：

优点：Java集合框架将数据结构和算法进行了分离，使算法独立于不同的容器类，**对不同的集合提供统一的遍历算法。**迭代器是按次序一个个获取集合中所有的对象，是目前遍历集合中元素的最简单也是最标准的处理机制。不需要索引。

迭代器的创建（不同的集合类都对该方法提供了不同的实现）：

List  list  =  new  ArrayList();  
Iterator iter  =  list.iterator(); //返回与ArrayList对应的迭代器
Set  set  =  new  HashSet();  
Iterator iter  =  set.iterator(); //返回与HashSet对应的迭代器

Iterator接口中的方法：

boolean hasNext( )   判断集合中是否还存在下一个元素，有则返回true，否则返回false

Object next( )   返回下一个元素。如果没有下一个元素，则引发NoSuchElementException异常

void remove( )  删除上次访问返回的对象，如果试图在调用next( )方法之前，调用remove( )方法，则引发IllegalStateException异常

迭代器遍历Collection：

while(iter.hasNext()){  //判断集合中是否还有元素
    System.out.println(iter.next());//next方法取出下一个元素    
}