学习Java之集合

Posted 2021-07-28 So istes immer

1.什么是集合？

集合：存储数据的容器，集合里存放对象，而非基本数据类型

数组和集合都是容器，有何不同?
①数组长度固定，集合长度可变
②数组只能存放相同类型的数据，集合可以存放不同类型的数据
③数组可存放简单数据类型和类类型的数据，集合只能存放类类型数据

两种类型的容器
Collection：一组各自独立的元素，包括List, Set
Map: 成对的key-value对象

2.Array的一些方法

①fill()方法使用给定值，填充一个数组。
[‘a’, ‘b’, ‘c’].fill(7) // [7, 7, 7]
new Array(3).fill(7) // [7, 7, 7]

3.对象集合Set

①Set接口：
Collection接口的子接口，方法和Collection中的一致
Set中的元素无顺序
存储的对象不允许重复
常用实现类：HashSet
HashSet采用了哈希散列算法存储元素。当需要添加新的对象时，先根据该对象的hashcode()方法确定它在内存中的存放地址
如果该位置上没有其他对象，就直接存储在这个位置上；
如果该位置上已经有对象了，就调用equals()方法对两个对象进行比较，相同就不允许添加，不同就以链表的方式散列到该位置其他元素的后面

用HashSet实现软键盘上的10个随机数字

import java.util.HashSet;
import java.util.Set;

public class SoftKeyBoard {
	public static void main(String[] args) {
		 int[] Keyboard =new int[10];
	     Set<Object> s=new HashSet<Object>();
	     int index=0;
	     while(s.size()<10){
	     	int temp=(int)(10*Math.random());
	        if(s.add(temp+"")){
	            Keyboard[index]=temp;
	         	System.out.print(temp+" ");
	            index++;
	        }
	    }
	}
}

LinkedHashSet：以元素插入的顺序来维护集合的链接表，允许以插入的顺序在集合中迭代
②SortedSet接口：
Set接口的子接口
具有排序功能的Set，默认将元素按照升序排列
常用实现类：TreeSet
TreeSet：提供一个使用树结构存储Set接口的实现，对象以升序顺序存储，访问和遍历的时间很快

4.对象列表List

①ArrayList类:
以数组的形式对List接口提供了实现，是容量可动态增长的数组
允许存储任意元素，包括重复对象和null空对象
以索引号方式存取对象
ArrayList是非同步的（unsynchronized），多线程并发访问时不安全
执行效率：
插入删除低效：元素在进行插入删除操作时，会影响后续的所有元素
查询高效：可根据索引号快速检索元素
List中的方法

例子

public class ListDemo1 {
    public static void main(String args[]) {
        List list = new ArrayList();
        for (int i = 1; i <= 10; i++)
            list.add(i + " * " + i + " = " + i * i);
        Iterator iter = list.iterator();
        while (iter.hasNext())
            System.out.println(iter.next());
    }
}

结果

1 * 1 = 1
2 * 2 = 4
3 * 3 = 9
4 * 4 = 16
5 * 5 = 25
6 * 6 = 36
7 * 7 = 49
8 * 8 = 64
9 * 9 = 81
10 * 10 = 100

遍历List中的元素

for(int i=0; i<list.size(); i++){
	System.out.println(list.get(i));	
}

②LinkedList类:
List接口的实现类，以双向链表的形式存储数据
不支持多线程并发访问
执行效率：
插入删除高效：元素在进行插入删除操作时，只会影响插入位置前后的元素结点，其他位置元素不受影响
查询低效：查询某个元素时，只能从第一个元素顺序往后或从最后一个元素顺序往前查找

小结
1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构
2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针
3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据

③Vector:
底层用数组实现List接口的另一个类
特点：重量级,占据更多的系统开销,线程安全
List list=new Vector();
list.add();
Stack(堆栈)是继承自Vector的。(间接实现List接口)
特点:先进后出,后进先出
Stack s=new Stack();
s.push();
s.pop();

5.对象映射Map

Map中的元素都是成对出现的，以键值对映射的形式存储和管理数据
每个对象都有一个唯一的key值，每个key对应一个value ，通过key可以实现对value对象的访问
key和value都为Object对象
Key对象唯一不重复，value对象允许重复
Map接口常用实现类：HashMap，Hashtable
HashMap类 ：
Map的实现类，与HashSet类似，底层也采用哈希散列算法管理映射， 通过key的哈希码进行散列运算，计算出与之对应的value在内存中的位置
key对象必须实现hashCode()和equals()方法
HashMap中存储的映射无顺序
允许存储null键和null值
是线程不安全的
Hashtable类：
与HashMap高度相似
不允许存储null键和null值
线程安全的

①SortedMap接口：
Map的子接口，在Map的基础上对元素进行排序
元素只能根据key值进行排序
实现类：TreeMap
注：如果存储的对象本身具有唯一的key值，应该采用Map存储，否则应该采用Collection
TreeMap类：
SortedMap子接口的实现类
具有排序功能，默认按升序排列

②Map.Entry接口：
存储键值对的映射关系, 每个Map.Entry对象代表Map中一个特定的键/值对
Map接口提供了entrySet()方法返回所有的映射集合
该接口中提供了方法访问映射关系两端的key与value对象
getKey()：获取该对象的key值
getValue()：获取该对象
setValue()：修改value对象

Map中的方法

添加元素

Map  map  =  new  HashMap();
String  s1 = “hello”;
String  s2 = new String(“java”);
map.put(new Integer(1), s1);
map.put(new Integer(2), s2);

删除元素

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]);

遍历所有value

Object[] values = map.values().toArray();
for(int i=0; i<values.length; i++){
 	System.out.println("value: "+values[i]);

遍历所有映射

Object[] entrys = map.entrySet().toArray();
for(int i=0;i<entrys.length;i++){
	Map.Entry entry = (Map.Entry)entrys[i];
	System.out.println(entry.getKey()+“ : "+entry.getValue());

Map.Entry 是Map中的一个接口，他的用途是表示一个映射项（里面有Key和Value）
Map.Entry里有相应的getKey和getValue方法，让我们能够从一个项中取出Key和Value

例子
统计句子中每种单词的个数

import java.util.*;
public class MapDemo1 {
     private static final Integer ONE = new Integer(1);
     public static void main(String args[]) {
          Map m = new HashMap();
          for (int i=0; i<args.length; i++) {
                Integer freq = (Integer) m.get(args[i]);
                m.put(args[i], (freq==null ? ONE:new Integer(freq.intValue() + 1)));
          }
          System.out.println(m.size()+" distinct words detected:");
          System.out.println(m);
    }
}

测试结果

D:\\java MapDemo1 if it is to be it is up to me to delegate 
 8 distinct words detected: 
{to=3, me=1, delegate=1, it=2, is=2, if=1, be=1, up=1}

6.集合的遍历

①List中的for循环遍历

for(int i=0; i<list.size(); i++){ 
	System.out.println(list.get(i));	
}

②Set中的for循环遍历

Set s = new HashSet();
for(int j=0;j<s.size();j++){
   System.out.println(s.get(j));
}

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

不同的集合类因其不同的特性，采用for循环遍历时就会有不同的实现方式
Iterator迭代器遍历：对不同的集合提供统一的遍历算法
Iterator接口中的方法

迭代器的创建

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

遍历（不同的集合类的遍历代码都一样）

while(iter.hasNext()){
	System.out.println(iter.next());	
}

迭代器遍历Map
将key或value转换成Collection集合，再迭代遍历
遍历所有的key

Iterator iter = map.keySet().iterator();
while(iter.hasNext()){
	System.out.println(iter.next());	
}

遍历所有的value

Iterator iter = map.values().iterator();
while(iter.hasNext()){
	System.out.println(iter.next());	
}

遍历所有的映射

Iterator iter = map.entrySet().iterator();
while(iter.hasNext()){
	Map.Entry  entry = (Map.Entry)iter.next();	
	System.out.println(entry.getKey()+“ : "+entry.getValue());
}

7.小结

接口的层次关系

当对象放入容器时，型别信息就被损失
容器中保存的都是引用，需要自己维护其类型