Java——集合

集合

集合类：提供一种存储空间可变的存储模型

Collection

• 多态方式创建
• 具体实现类为ArrayList

package javaee.List;

import java.util.ArrayList;
import java.util.Collection;

public class Collection_demo {
	public static void main(String[] args) {
		Collection<String> c = new ArrayList<>();
		
		c.add("java");
		c.add("hello");
		c.add("world");
		c.add("java");
		
		// 该集合中可以有重复元素
		System.out.println(c);
		//输出 [java, hello, world, java]
		
		System.out.println(c.remove("java"));
		//移除集合中的内容，若有多个则移除第一个元素
		//会返回一个布尔值
		
		System.out.println(c);
		// [hello, world, java]
		
		System.out.println(c.size());
		//返回集合中元素的个数 3
		
		c.clear();
		//清空集合中元素 
		//void类型
			
	}
	
}

迭代器（集合专用遍历方式）

package javaee.List;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Collection_demo {
	public static void main(String[] args) {
		Collection<String> c = new ArrayList<>();
		
		c.add("java");
		c.add("hello");
		c.add("world");
		c.add("java");
		
		//Iterator读取集合中内容
		Iterator<String> t = c.iterator();
		while(t.hasNext()) {
			System.out.println("数据为："+ t.next());
		}		
	}
}

list

• void add(int index , E element) 添加

  • 添加内容的索引号不可超过现有集合的个数

• E remove()

• E set(int index , E element) 修改指定索引内容

• E get(int index) 得到指定内容

并发修改异常

如下面的代码，看似正常，但是会报一个ConcurrentModificationException的错误，这是因为了迭代器获取元素中判断预期修改值和实际修改值不一致，想要实现该功能，需要使用for循环来做。

//遍历集合，得到每一个元素，看有没有"world"这个元素，如果有的话，就添加一个"javaee"元素// 
Iterator<String> it = list.iterator(); 
while (it.hasNext()) { 
	String s = it.next(); 
	if(s.equals("world")) { 
    	list.add("javaee"); 
    } 
}

for(int i = 0;i<list.size();i++){
	String s = list.get(i);
	if(s.equel("world")){
		list.add("javaee");
	}
}

列表迭代器

通过list集合listIterator()方法得到

可沿任意方向遍历列表，迭代期间修改列表，并获取列表中迭代器的当前位置
列表迭代器有add方法，而iterator没有

		ListIterator<String> listl = l1.listIterator();
		while(listl.hasNext()) {
			String s = listl.next();
			if(s.equals("mc")) {
				listl.add("qq");
			}
		}
		//列表迭代器中会随时修改当前的修改次数，所以可以这样子修改

增强for

内部原理为一个迭代器

list集合子类

ArrayList：底层数组，查询快，增删慢
LinkedList: 底层链表，查询慢，增删快

set

• 不包含重复元素
• 没有带索引方法，不可使用增强for循环遍历

Set<String> set = new HashSet<>();
set.add("hello");
set.add("hello");
set.add("java");

for(String s : set) {
System.out.println(s);
}

哈希值

• JDK根据对象的地址或字符串或数字算出来的int类型的数值
• hashCode()获取
• 注意 同一个对象多次调用hashCode()方法返回的哈希值是相同的

HashSet

• 底层是哈希表
• 对迭代出的数据顺序不做保证
• 无重复
• 默认初始容量16

HashSet<String> hs = new HashSet<>();

• 在对一个对象进行存储时，需要重写它的hashcode和equals方法，以实现哈希表无重复的特点

哈希表

按照哈希值进行排放，哈希值对存储容量取余得到位置，若取余值相同时，则判断是否是相同的存放内容

LinkedHashSet

• 由链表和哈希表实现
• 元素有序且唯一

TreeSet

• 元素有序，会以默认方式排序或以TreeSet(Comparator comparator)排序

• 不含重复元素

• 使用Comparator时，需要先在使用的类中实现comparable接口，然后才可以实现comparator方法
  ++ 返回0表示相同

//在类里面重写方法
@Override
	public int compareTo(student o) {
		// TODO Auto-generated method stub
		//return 0;

        // 如果都返回0，那么只能存储一个，因为它返回0默认后面的对象都一样

        //return 1;

        //按输入的顺序输出，返回一个整数，认为比之前一个大

        //return -1;

        //逆序

        int num = this.age-o.age;

        //比较年龄，按照升序

        int num1=num==0?this.name.compareTo(o.name):num;

        //年龄相同，比较姓名

        return num1;
	}

Map

键值对，Interface Map<K,V> K：键的类型 V：值的类型

public class map_demo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Map<String, String> mp = new HashMap<String, String>();
		mp.put("01", "kik");
		mp.put("02", "兰陵");
		mp.put("03", "亚瑟士");
		
		System.out.println(mp);
		
		System.out.println(mp.get("02"));
		
//		mp.containsKey(key);
//		mp.containsValue(value);
//		得到是否包含键和值 
//		mp.isEmpty判断是否为空
	}
}

遍历

	//方法一
	//获取所有键的集合
    Set<String> keyset = mp.keySet();
    for(String s : keyset) {
    System.out.println(mp.get(s));
    }

	//方法二
	//获取map
	Set<Map.Entry<String, String>> entrySet = mp.entrySet();
    for(Map.Entry<String, String> me : entrySet) {
        String key = me.getKey();
        String value = me.getValue();
        System.out.println(key +"++"+value);
    }

Collection

Collection.sort()排序
Collection.reverse()反转
Collection.shuffle()使用默认随机源随机排列指定列表