Java集合（set，list，map）

程序员文章站 2022-03-08 17:25:06

...

一。Set集合：

Set集合的特征是：不能存储相同的元素。而且是无序的，集合存在的意义就是储存对象
同时因为其是一个抽象的接口：所以不能直接实例化一个set对象。(Set s = new Set() )错误
该接口主要继承于Collections接口，所以具有Collection的一些常见的方法。
Set接口最长用的两大实现：HashSet TreeSet 还有一个是linkedSet
set中的方法及运用：（我们先创建一个Set列表）

//HashSet 内部储存的是一个散列表， HashSet内部实现是一个HashMap(下面就是HashSet)
public class SetDeno { //类名

public static void main(String[] args) {
	//接口      = 实现类
	Set<String> set = new HashSet<String>();
	//实现类    = 实现类
	HashSet<String> set2 = new HashSet<String>();
	set2.add("dahuang")	;
	//set提供方法 add( )         向集合中添加元素：
	set.add("ac");
	set.add("hello");
	set.add("hi");
	set.add("jaba");
	set.add("hava");
	set.add("jabva");
	set.add("java");
	set.add("oko");
	set.add("sasd");
	set.add("hmld");
	//set不可一重复存放相同元素
	set.add("java");
	//遍历set集合
	System.out.println(set.toString());
	//数组的长度
	System.out.println(set.size());
	//addall
	set.addAll(set2);
	System.out.println(set.toString());
	//clear   清除集合中的所有元素
	set.clear();
	System.out.println(set.size());   //   打印出来的是 0
	//是否包含某个元素
	System.out.println(set.contains("dahuang"));
	//hashCode值
	System.out.println(set.hashCode()); 
	//删除某个元素
	set.remove("dahuang");
	System.out.println(set.toString());
	//结合的遍历方法1 ：       toArray
	Object[] object = set.toArray();
	for (Object obj : object) {
		String str  = (String)obj;
		System.out.print(str+" ");
	}
	System.out.println();
	System.out.println("----------------------");
	//集合的遍历方法2： forEach
	for (String str : set) {
		System.out.print(str+" ");
	}
	System.out.println("/n---------");
	//集合的遍历方法3：     ITearor    迭代器    游标
	Iterator<String> it = set.iterator();
	while(it.hasNext()){//hasNext   下一位是否有值
		System.out.println(it.next()+" ");//输出下一个的值
	}
}

}

TreeSet 是否排序的集合，默认按照字典或者数字顺序排列。

public class TreeSetDemo2 {

public static void main(String[] args) {
	Set<String> set = new TreeSet<>();
	set.add("1hello");
	set.add("2hi");
	set.add("5aa");
	set.add("6aaaa");
	for (String str : set) {
		System.out.println(str);
	}
}

}
有数字是这样的
Java集合（set，list，map）
字母是这样的，这样及可以看见是按顺序排列的

LinkedHashset 有链表顺序，不能重复：

public class LinkedHashSetDemo {

public static void main(String[] args) {
	Set<String> set = new LinkedHashSet<>();       // LinkedHashSet列表，方法差不多都一样
	set.add("hello");
	set.add("hi");
	set.add("nuea");
	set.add("css");
	set.add("css");  //不能重复（看下面图）
	for (String str : set) {
		System.out.println(str+" ");
	}
}

}
Java集合（set，list，map）
可以看见只有一个css：下面就是list集合

list：集合：储存的元素，有序的可重复的

ArrayList 内部的储存原理是数组，默认构建的容量是10
public class ArrayListDemo { //先说ArrayList ，比较常用

public static void main(String[] args) {
	// 创建数组
	ArrayList<String> list = new ArrayList<>();
	//向集合内部追加元素
	list.add("e");
	list.add("d");
	list.add(null);
	list.add("b");
	list.add("g");
	list.add("g");
	list.add(0, "[");
	list.add(null);
	list.add(null);
	//add 方法有返回值。是否添加成功
	boolean add = list.add("}");
	
	//list集合的浅表赋值，克隆副本
	ArrayList clone = (ArrayList)list.clone();
	 
	//remove 移除元素
	String remove = list.remove(0);  //通过下标移除某个元素，返回值删除的元素
	boolean remove2 = list.remove("a");//通过元素本身，删除
	
	//get方法，，获取通过下表获取
	System.out.println(list.get(1));
	
	//indexof
	System.out.println(list.indexOf("b"));//返回元素的下标位
	
	//inEmpty
	System.out.println(list.isEmpty());
	
	//set    替换 ，更新
	list.set(0, "cc");
	System.out.println(list);
	
	//size 集合长度
	System.out.println(list.size());
	
	//toArray
	Object[] array = list.toArray();
	System.out.println("----------------------------");

	//遍历集合1.
	for(int i=0;i<list.size();i++){
		System.out.print(list.get(i)+" ");
	}
	
	//遍历集合2
	System.out.println();
	System.out.println("--------------");
	Iterator<String> iterator = list.iterator();
	while(iterator.hasNext()){ //下一位是否还有值
		System.out.println(iterator.next()+" ");
	}
}

}
打印出来的结果如下：
Java集合（set，list，map）

说一下ArrayList和linkedlist的区别

/**

LInkedList 链表集合内存储存是按照链表顺序排序的，双向链表
ArrayList 和 LinkedList的区别
ArrayList 内部储存使用的是数组遍历速度快
LinkedList 内部储存使用的是链表，遍历速度慢插入删除性能快
ArrayList 是使用数组方式储存数据，次数组元素大于实际储存的数据以便利增加和插入元素，他们都允许直接按序号索引元素
但是插入元素要涉及数组元素移动等内存操作，所以索引数据块而插入数据慢，而linkedList使用双向链表实现储存

按序号索引数据需要进行前后遍历，但是插入数据是指需要记录本项的前后项即可。所以插入速度快
*/
public class LinkedListDemo { //方法其实和上面差不多
public static void main(String[] args) {

 LinkedList<String> list = new LinkedList<>();
 list.add("hllo");
 list.add("ja");
 list.add("jck");
 list.add("tom");
 list.add("rose");
 list.add("ob");
 //链表提供了添加的方法，addFirst     addlast
 list.addFirst("{");
 list.addLast("}");
 
 list.removeFirst();
 list.removeLast();
 
 //获取元素
 System.out.println(list.get(0));
 System.out.println(list.element());
 System.out.println(list.toString());

}
}

List里面还有一个是线程安全的集合 Vecto

r
public class VectorDemo {

public static void main(String[] args) {

	Vector<String> vector = new Vector<>();
	vector.add("hello");
	vector.add("world");
	vector.add("smind");
	vector.add("fade");
	vector.add("jack");
	System.out.println(vector.toString());

// System.out.println(vector); 和上面打印的是一样的，可以不写tostring
}
}

下面是Map集合：（map 集合：一个包含键值对映射的对象集合）

/**

HashTable 和 hashMap的区别
HashMap是非线程安全的。效率高
HashTable是线程安全的，效率低
HashMap是HashTable的轻量级实现（非线程安全的实现）
他们都完成了Map接口，主要区别在于HashMap允许空（null）键值（Key），由于非线程安全，效率上可能高于HashTable
HashMap允许将null作为一个entry的key或者value。而HashTable不允许
HashMap的父类是：abstractMap 把HashTable的contains方法去掉了，改成containsValue和
containsKey。因为contains方法容易让人引起误解。
HashTable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现
最大的不同是
HashTable的方法是Synchronize的，而HashMap不是，在多个线程访问HashTable时。不需要自己为它
的方法实现同步，而HashMap 就必须为之提供外同步。

HashTable和HashMap采用的hash/rehash算法都是大概一样，所以性能不会有很大的差异
*/
public class HashTableDemo {

public static void main(String[] args) {

 HashMap<String, String> hashMap = new HashMap<>();
 hashMap.put("a", "hello");
 hashMap.put("b", "world");
 hashMap.put("c", "jack");
 hashMap.put("d", "tom");
 hashMap.put(null, "tom");          //添加元素
 hashMap.containsKey("a");           //HashMap允许有空值
       
 Hashtable<String, String> hashtable = new Hashtable<>();
 hashtable.put("a", "hello");
 hashtable.put("b", "world");
 hashtable.put("c", "jack");
 hashtable.put("d", "tom");
 //hashtable.put(null, "tom");// hashtable 不允许空的key。
 System.out.println(hashtable.contains("hello"));// 是否包含某个key

}
}
key ：键
value：值
一个键只能对应一个值。键不能重复。无序的，值可以重复
public class HashMapDemo {

public static void main(String[] args) {

 //        Key    Value
 HashMap<String, Integer> map = new HashMap<>();
 //map是键值对映射的集合。         “a”表示Key      97表示Value
 map.put("a", 97);
 map.put("男", 98);
 map.put("b", 67);
 map.put("c", 164);
 
 //获取map集合中的值
 System.out.println(map.get("a")); //get获取集合中的值，通过键获取值
 System.out.println(map.get("男"));
 System.out.println(map.get("女"));
 
 //containsKey    是否包含某个Key
 System.out.println(map.containsKey("a"));       //查看是否包含某个键
 //containsValue  是否包含某个值Value
 System.out.println(map.containsValue(98));      //查看这个列表里面是否包含这个值  返回值是一个Boolean类型
 
 //遍历HashMap集合。  遍历所有的key
 Set<String> set = map.keySet();        //遍历这个集合里面所有的key
 for(String str : set){
 	//遍历所有的key
 	System.out.println("key:  "+str+"\tvalue"+map.get(str));
 }
 
 System.out.println("*****************");
 //遍历HashMap集合
  Collection<Integer> values = map.values();
  for(Integer integer : values){
 	 System.out.println(integer);
  }
  System.out.println("*****************");
  //遍历HashMap集合
  //视图 副本  克隆
  for (Entry<String, Integer> entry :map.entrySet()) {
 	 System.out.println(entry.getKey()+"\t"+entry.getValue());
 	 }
  	System.out.println("**********");
 //集合中药注意的地方
  	map.put("a", 197);   //重复的key覆盖原来的value
  	System.out.println(map.get("a"));
  	
  	//集合中药注意的地方，put方法将放回原来的旧值，新值替换旧值
  	System.out.println(map.put("a", 1000));
  	System.out.println(map.get("a"));
  	
  	//集合中要注意的地方
  	System.out.println(map.put("hello", 885));     //想这个列表里面添加键值
  	
  	//set      add(object);    返回boolean类型
  	//list     add(object);    返回Boolean类型
  	//map      put(key,value)  返回value的旧值
  	//set      remove(object)  返回boolean类型
  	//list     remove(object)  返回被删除的元素
  	//map      remove(key)     返回value的旧值
  	
  	//集合中药注意的地方
  	Integer remove  = map.remove("a");
  	System.out.println(remove);   //删除的返回值是a的value
  	System.out.println(map.toString());

}
}

LikedHashMap ：维护了Key插入时的链表顺序

public class LinkedHashMapDemo {

public static void main(String[] args) {
	LinkedHashMap<String,Integer> map = new LinkedHashMap<>();    //创建一个Map集合
	map.put("a", 1);
	map.put("c", 2);
	map.put("e", 3);
	map.put("f", 4);
	map.put("t", 5);
	
	for(String key : map.keySet()){     //遍历所有的Key的值
		System.out.println(key+"\t"+map.get(key));   //.打印这些key和他所对应的值
	}
	System.out.println("**********");
	HashMap<String, String> hashMap = new HashMap<>();
	hashMap.put("张三", "hello");
	hashMap.put("大黄", "world");
	hashMap.put("jack", "jack");
	hashMap.put("tom", "tom");
	hashMap.put(null, "tom");
	for(String key : hashMap.keySet()) {        //遍历所有的key
		System.out.println(key+"\t"+hashMap.get(key));
	}
}

}

Java集合（set，list，map）

一。Set集合：

TreeSet 是否排序的集合，默认按照字典或者数字顺序排列。

LinkedHashset 有链表顺序，不能重复：

list：集合：储存的元素，有序的可重复的

说一下ArrayList和linkedlist的区别

List里面还有一个是线程安全的集合 Vecto

下面是Map集合：（map 集合：一个包含键值对映射的对象集合）

LikedHashMap ：维护了Key插入时的链表顺序

java中数组list map三者之间的互转介绍

Java实现过滤掉map集合中key或value为空的值示例

ES6——Set&&Map集合

java集合Collection,Map及子类

java集合Collection,Map及子类

java集合中list的用法代码示例

java集合中的list详解

java如何对map进行排序详解(map集合的使用)

浅析Java集合及LIst接口

Java实现Map集合遍历的四种常见方式与用法分析

Java集合（set，list，map）

一。Set集合：

TreeSet 是否排序的集合， 默认按照字典或者数字顺序排列。

LinkedHashset 有链表顺序，不能重复：

list：集合： 储存的元素，有序的可重复的

说一下ArrayList和linkedlist的区别

List里面还有一个是线程安全 的集合 Vecto

下面是Map集合：（map 集合：一个包含键值对映射的对象集合）

LikedHashMap ：维护了Key插入时的链表顺序

java中数组list map三者之间的互转介绍

Java实现过滤掉map集合中key或value为空的值示例

ES6——Set&&Map集合

java集合Collection,Map及子类

java集合Collection,Map及子类

java集合中list的用法代码示例

java集合中的list详解

java如何对map进行排序详解(map集合的使用)

浅析Java集合及LIst接口

Java实现Map集合遍历的四种常见方式与用法分析

TreeSet 是否排序的集合，默认按照字典或者数字顺序排列。

list：集合：储存的元素，有序的可重复的

List里面还有一个是线程安全的集合 Vecto