Java 常用集合类学习


  

1 Collection集合

1.1 Collection集合简介

  集合是用来存储引用类型数据的容器, 注意,集合不能存储基本类型数据
  集合分类两类:
    1)Collection集合, 是单个存储数据
    2)Map集合,是按<键,值>对的形式存储数据, <”张三”, 28> <”李四”, 30>
  java.util.Collection集合框架
在这里插入图片描述

1.2 Collection集合基本操作

返回值类型说明
booleanadd(E e) 向集合中添加元素e
booleanaddAll(Collection<? extends E> c) 把参数集合c中的所有元素添加到当前集合中
voidclear() 清空集合中所有元素.
booleancontains(Object o) 判断当前集合是否包含指定的元素o
booleanisEmpty() 判断当前集合是否为空.
Iteratoriterator() 返回集合的迭代器
booleanremove(Object o) 在集合中删除第一个与o匹配的元素
intsize() 返回集合中元素的个数.
Object[]toArray() 把集合转换为数组
T[]toArray(T[] a)
/**
 * Collection的基本操作
 */
public class Test01 {

	public static void main(String[] args) {
		//1)创建Collection集合, Collection是一个接口,需要赋值实现类对象
		//一般情况下, 在集合中存储的元素都是同一类型的元素,在创建集合时, 可以通过泛型指定集合 中元素的数据类型
		//如创建一个存储String字符串的集合, 通过泛型指定集合的元素是String类型
		Collection<String> collection = new ArrayList<>();
		
		//2)向集合中添加元素
		//注意,在创建集合中通过泛型指定集合存储元素的类型是String, 只能添加String字符串
		collection.add("gg");
		collection.add("jj");
		collection.add("mm");
		collection.add("dd");
		collection.add("mm");
		//泛型的好处就是在编译时可以进行数据类型的检查,
//		collection.add( 456 ); 		//如果添加的数据不是String类型, 语法错误
		
		//3)直接打印, collection引用的是ArrayList对象, 打印时,会调用ArrayList对象的toString()
		System.out.println( collection );  	//[gg, jj, mm, dd, mm]

		//4)判断
		System.out.println( collection.size() );
		System.out.println( collection.isEmpty());
		System.out.println( collection.contains("gg"));
		System.out.println( collection.contains("mm"));
		
		//5)删除第一个匹配的元素
		collection.remove("mm");
		System.out.println( collection ); 		//[gg, jj, dd, mm]
		
		//6) addAll()
		Collection<String> collection22 = new ArrayList<>();
		collection22.addAll(collection);  		//把collection集合中的所有元素添加到collection22集合中
		
		//7)清空
		collection.clear();
		System.out.println(collection);
	}

}
[gg, jj, mm, dd, mm]
5
false
true
true
[gg, jj, dd, mm]
[]

Process finished with exit code 0

1.3 Collection集合迭代

/**
 * 集合迭代
 */
public class Test02 {

	public static void main(String[] args) {
		//创建Collection,存储String字符串
		Collection<String> collection = new ArrayList<>();
		//添加元素
		collection.add("jj");
		collection.add("jj");
		collection.add("dd");
		collection.add("dd");
		collection.add("mm");
		collection.add("mm");
		System.out.println( collection );  
		
		//迭代遍历集合中的内容
		//获得集合的迭代器
		Iterator<String> iterator = collection.iterator();
		/* 在iterator迭代器中,有一个游标, 开始游标指向第一个元素的前面
		 * iterator迭代器,有一个hasNext()方法,判断是否还有没访问的元素
		 * 迭代器有next()方法, 返回下个元素, 把游标下移
		 */
		while( iterator.hasNext() ){
			String str = iterator.next();
			System.out.print( str + "\t");
		}
		System.out.println();
		//while循环完后,这个迭代器的游标已经指向最后了, 这个iterator迭代器就不能再使用了
		//如果还想迭代的话, 需要重新调用iterator()方法,获得一个新的迭代器对象
		
		//Collection集合的remove( o )可以删除第一个匹配的元素
		collection.remove("jj");
		//需求:删除所有的dd,  
		//遍历集合中的所有元素,如果该元素与dd相同就删除
		iterator = collection.iterator(); 			//重新获得迭代器
		while (iterator.hasNext()) {
			String string =  iterator.next();
			if ( "dd".equals(string) ) {
//				collection.remove("dd"); 		//在迭代过程中,不能使用Collection集合的add()/remove()添加/删除元素
				iterator.remove(); 			//迭代删除
			}
		}
		System.out.println(collection);  	
		
	}
}
[jj, jj, dd, dd, mm, mm]
jj	jj	dd	dd	mm	mm	
[jj, mm, mm]

Process finished with exit code 0

2 List集合

  特点:
  1)有序,可重复
  2)存储顺序与添加的顺序一样, 可以存储重复的数据
  3)List接口继承了Collection接口, Collection有的操作List都能继承到

2.1 List集合的基本操作

/**
 * List集合的基本操作
 */
public class Test03 {

	public static void main(String[] args) {
		//1)创建List集合, List是一个接口, 需要赋值实现类对象
		//创建一个List集合,存储String字符串, 通过泛型指定存储元素的数据类型
		List<String>  list = new ArrayList<>();
		//2)添加元素
		list.add("jj");
		list.add("mm");
		list.add("mm");
		list.add("dd");
		//3)直接打印, 打印的顺序与添加的顺序一样, 可以有重复的数据
		System.out.println(list);   //[jj, mm, mm, dd]
		//4)判断
		System.out.println( list.isEmpty());
		System.out.println( list.size());
		System.out.println( list.contains("jj"));
		System.out.println( list.contains("xx"));
		//5)删除第一个匹配的元素
		list.remove("jj");
		System.out.println( list );  //[mm, mm, dd]
		//6)迭代遍历
		Iterator<String> iterator = list.iterator();
		while (iterator.hasNext()) {
			String string = (String) iterator.next();
			System.out.print( string + "\t");
		}
		System.out.println();
		//7)迭代删除 mm
		iterator = list.iterator();
		while (iterator.hasNext()) {
			String string = (String) iterator.next();
			if ("mm".equals(string)) {
				iterator.remove();
			}
		}
		System.out.println( list );
	}
}
[jj, mm, mm, dd]
false
4
true
false
[mm, mm, dd]
mm	mm	dd	
[dd]

Process finished with exit code 0

2.2 List集合针对索引的操作

/**
 * List为每个元素指定了索引值,增加了针对索引值的操作
 *
 */
public class Test04 {

	public static void main(String[] args) {
		//创建一个存储String字符串的List集合
		List<String> list = new ArrayList<>();
		//添加元素
		list.add("jj");
		list.add("jj");
		list.add("dd");
		list.add("mm");
		list.add("mm");
		list.add("dd");
		System.out.println( list );  		//[jj, jj, dd, mm, mm, dd]
		
		//1)在指定的位置添加元素, 注意索引值不能越界[0, list.size() ] 
		list.add(0, "xx");
		System.out.println( list );   		//[xx, jj, jj, dd, mm, mm, dd]
		list.add( list.size(), "yy");
		System.out.println( list ); 		//[xx, jj, jj, dd, mm, mm, dd, yy]
		//2)返回元素第一次出现的索引值
		System.out.println( list.indexOf("jj"));
		System.out.println( list.lastIndexOf("jj"));
		//3)删除指定位置的元素
		list.remove(3);
		System.out.println( list );  		//[xx, jj, jj, mm, mm, dd, yy]
		//4)返回指定位置的元素
		System.out.println( list.get(0));			
		System.out.println( list.get(list.size() - 1));
		//通过循环返回所有的元素
		for(int i = 0 ;  i<list.size();i++){
			System.out.print( list.get(i) + "\t");
		}
		System.out.println();
	}

}
[jj, jj, dd, mm, mm, dd]
[xx, jj, jj, dd, mm, mm, dd]
[xx, jj, jj, dd, mm, mm, dd, yy]
1
2
[xx, jj, jj, mm, mm, dd, yy]
xx
yy
xx	jj	jj	mm	mm	dd	yy	

Process finished with exit code 0

2.3 使用List存储自定义对象

/**
 * List集合,可以存储自定义类型对象, 在调用contains()/remove()方法时,需要调用对象的equals()方法, 需要重写equals()
 * 
 * 	创建一个List集合,存储Person对象
 * 	向list集合中添加Person对象,
 * 	判断List集合中是否包含指定的Person对象
 * 	删除指定的Person对象
 * 	迭代遍历List集合中所有的Person对象
 */
public class Test01 {

	public static void main(String[] args) {
		//创建一个List集合,存储Person对象
		List<Person> list = new ArrayList<>();		
		//向list集合中添加Person对象,
		list.add(new Person("lisi", 28));
		list.add(new Person("wang", 18));
		list.add(new Person("zhao", 38));
		list.add(new Person("chen", 48));
		Person feifei = new Person("feifei", 26);
		list.add( feifei );		
		System.out.println( list );
		
		//判断List集合中是否包含指定的Person对象
		System.out.println( list.contains( feifei ) ); 		//true
		Person lisi = new Person("lisi", 28);
		System.out.println( list.contains(lisi) ); 			//true
	
		
		//删除指定的Person对象,在List集合remove()删除时,先找到这个对象再删除, 在找相同的对象时,需要调用对象的equals()方法
		list.remove( new Person("zhao", 38) );
		System.out.println( list );
		
		//	迭代遍历List集合中所有的Person对象
		Iterator<Person> iterator = list.iterator();
		while (iterator.hasNext()) {
			Person person = (Person) iterator.next();
			System.out.println( person );
		}
		System.out.println("---------------");
		for (Person person : list) {
			System.out.println(person);
		}
	}
}
class Person {
	String name;
	int age;
	
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	@Override
	public String toString() {
		return " [name=" + name + ", age=" + age + "]";
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person other = (Person) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}	
}

3 ArrayList与Vector比较

  1) 底层都是数组
  2) 默认初始化大小: 10
  3) ArrayList扩容: 1.5倍大小 ; Vector扩容: 2倍大小扩容
  4) Vector是线程安全的, ArrayList不是线程安全的
  5)虽然Vector是线程安全的, 但是现在开发多线程程序,使用CopyOnWriterArrayList

下图是ArrayLlist集合扩容的源码
在这里插入图片描述
下图是Vector集合扩容的源码
在这里插入图片描述

4 LinkedList

  1)底层是双向链表
  2)增加了针对第一个元素和最后一个元素的操作
在这里插入图片描述
在这里插入图片描述

/**
 * LinkedList增加了针对第一个元素/最后一个元素的操作
 */
public class Test03 {

	public static void main(String[] args) {
		LinkedList<String> linkedList = new LinkedList<>();
		
		linkedList.add("xx");
		linkedList.add("yy");
		linkedList.add("zz");
		System.out.println( linkedList );  	//[xx, yy, zz]

		//在头部/尾部添加
		linkedList.addFirst("aa");
		System.out.println(linkedList); 	//[aa, xx, yy, zz]
		linkedList.addLast("bb");
		System.out.println( linkedList ); 	//[aa, xx, yy, zz, bb]
		
		//删除第一个/删除最后一个
		linkedList.removeFirst();
		System.out.println(linkedList); 	//[xx, yy, zz, bb]
		linkedList.removeLast();
		System.out.println( linkedList ); 	//[xx, yy, zz]
	
		
		//返回第一个/最后一个
		System.out.println( linkedList.getFirst());
		System.out.println( linkedList.getLast());
		System.out.println( linkedList.peek()); 		//返回第一个元素
		System.out.println( linkedList.peekLast());		//返回最后一个元素
				
		//使用push()/pop()模拟栈
		//栈的特点, 后进先出
		linkedList.push("hh");  		//压栈,入栈, 把元素添加到列表的头部
		System.out.println(linkedList);
		System.out.println( linkedList.pop() ); 	//弹栈,出栈, 把列表的第一个元素删除并返回
		System.out.println(linkedList);
		
		//使用offer()/poll()模拟队列
		//队列特点: 先进先出
		linkedList.offer("mm"); 			//入队, 把元素添加到列表的尾部
		System.out.println( linkedList );
		System.out.println( linkedList.poll() );  //出队, 把列表的第一个元素删除并返回
		System.out.println(linkedList);
	}

}
[xx, yy, zz]
[aa, xx, yy, zz]
[aa, xx, yy, zz, bb]
[xx, yy, zz, bb]
[xx, yy, zz]
xx
zz
xx
zz
[hh, xx, yy, zz]
hh
[xx, yy, zz]
[xx, yy, zz, mm]
xx
[yy, zz, mm]

Process finished with exit code 0

4 Set

/**
 * Set特点:无序不可重复
 */
public class Test01 {

	public static void main(String[] args) {
		//1)创建Set集合,  Set是一个接口,需要赋值实现类对象
		Set<String> set = new HashSet<>();
		
		//2)添加元素
		set.add("666666");
		set.add("hehehehe");
		set.add("yingyingying");
		set.add("xixixixi");
		
		//3)打印, 存储顺序可能与添加的顺序不一样
		System.out.println( set );  //[hehehehe, xixixixi, 666666, yingyingying]

		//4)添加重复的数据
		set.add("666666");
		set.add("hehehehe");
		System.out.println( set );  //[hehehehe, xixixixi, 666666, yingyingying]
		
		//5)判断
		System.out.println( set.size() );
		System.out.println( set.isEmpty());
		System.out.println( set.contains("666666"));
		
		//6)迭代
		Iterator<String> iterator = set.iterator();
		while (iterator.hasNext()) {
			String string = (String) iterator.next();
			System.out.println( string );
		}
		
		//7)删除
		set.remove("666666");
		System.out.println( set );
	}
}

4.2 HashSet

  HashSet
   1)底层数据结构是HashMap
   2)向HashSet中添加元素,就是把该元素作为键添加到底层的HashMap中
   3)HashSet就是HashMap键的集合

4.2 TreeSet

  TreeSet
   1) TreeSet底层是TreeMap
   2) 向TreeSet添加元素就是把该元素作为键添加到了TreeMap中
   3) TreeSet就是TreeMap键的集合
   4) TreeSet类实现了SortedSet接口, 可以根据元素自然排序, 要求集合中的元素必须是可比较的
     (1) 在定义TreeSet时, 通过构造方法指定Comparator比较器
     (2) 如果没有指定Comparator比较器, 要求集合中元素的类实现Comparable接口

public class Test03 {

	public static void main(String[] args) {
		//1)创建TreeSet集合, 存储String字符串, 要求按字符串降序排序, 在创建TreeSet时指定Comparator比较器
		TreeSet<String>  treeSet1 = new TreeSet<>(new Comparator<String>() {
			//在匿名内部类中重写接口抽象方法 
			@Override
			public int compare(String o1, String o2) {
				return o2.compareTo(o1);  		//按字符串降序排序
			}
		});
		
		treeSet1.add("aaa");
		treeSet1.add("bbb");
		treeSet1.add("ggg");
		treeSet1.add("zzz");
		System.out.println( treeSet1 );   //[zzz, ggg, bbb, aaa]
		
		//2)如果创建TreeSet时,没有指定Comparator比较器,元素的类需要实现Comparable接口
		//Treeset集合存储String字符串, String类实现了Comparable接口
		TreeSet<String> treeSet = new TreeSet<>();
		treeSet.addAll(treeSet1); 		//把treeset1中的所有元素添加到treeset中
		System.out.println( treeSet );
	}

}
[zzz, ggg, bbb, aaa]
[aaa, bbb, ggg, zzz]

Process finished with exit code 0

5 Map集合

  Map是按<键,值>对的形式存储数据
  Map集合结构图
在这里插入图片描述

5.1 Map集合的常用操作

返回值类型操作
voidclear() 清空
booleancontainsKey(Object key) 判断当前Map中是否包含指定的键
booleancontainsValue(Object value) 判断是否包含指定的值
Set<Map.Entry<K,V>>entrySet() 返回Entry的集合, 一个<键,值>对就是一个Entry.
booleanequals(Object o)
Vget(Object key) 返回指定的键对应的值
booleanisEmpty() 判断是否为空.
SetkeySet() 返回所有键的集合.
Vput(K key, V value) 添加<key,value>键值对, 如果键已存在,使用value值替换原来的值
voidputAll(Map<? extends K,? extends V> m) 把m集合中所有的<键,值>对添加到当前集合中
Vremove(Object key) 删除指定键对应的<键,值>对
default booleanremove(Object key, Object value)
intsize() 返回键,值对的数量
Collectionvalues() 返回所有值的集合
public class Test01 {

	public static void main(String[] args) {
		//1)创建一个map集合,存储<员工姓名,员工工资> , Map是一个接口,需要赋值实现类对象
		//通过泛型指定键,值的数据类型
		Map<String, Integer>  map = new HashMap<>();
		
		//2)添加数据
		map.put("aa", 5000);
		map.put("bb", 6000);
		map.put("cc", 8000);
		map.put("dd", 9000);
		
		//3)直接打印
		System.out.println( map );  //{dubin=8000, ming=9000, yang=6000, feifei=5000}

		//4) 添加<键,值>对时, 键已存在, 使用新值替换了原来的值, Map中的键不能重复		
		map.put("gg", 4000);
		System.out.println( map );  //{dubin=8000, ming=9000, yang=4000, feifei=5000}

		//5) 判断
		System.out.println( map.isEmpty() );
		System.out.println( map.size());
		System.out.println( map.containsKey("aa"));
		System.out.println( map.containsKey("bb"));
		System.out.println( map.containsValue( 10000 ));
		System.out.println( map.containsValue( 8000 ));
		System.out.println( map.get("dd"));		//返回键对应的值
		System.out.println( map.get("ee")); 		//null  键不存在
		
		//6)删除
		map.remove("aa"); 		//删除与指定的键匹配的<键,值>对
		System.out.println( map );
		map.remove("bb");
		System.out.println( map );
		map.remove("cc", 6000);
		System.out.println( map );
		
		//7)返回所有键的集合
		Set<String> keySet = map.keySet();
		System.out.println( keySet );
		//8)返回所有值的集合
		Collection<Integer> values = map.values();
		System.out.println( values );
		//9)返回所有键,值对的集合
		Set<Entry<String, Integer>> entrySet = map.entrySet();
		for (Entry<String, Integer> entry : entrySet) {
			System.out.println( entry.getKey() + " : " + entry.getValue() );
		}
	}

}
{aa=5000, bb=6000, cc=8000, dd=9000}
{aa=5000, bb=6000, cc=8000, dd=9000, gg=4000}
false
5
true
true
false
true
9000
null
{bb=6000, cc=8000, dd=9000, gg=4000}
{cc=8000, dd=9000, gg=4000}
{cc=8000, dd=9000, gg=4000}
[cc, dd, gg]
[8000, 9000, 4000]
cc : 8000
dd : 9000
gg : 4000

Process finished with exit code 0

5.2 Map集合的应用

public class Test02 {

	public static void main(String[] args) {
		String text = "adfasfafdasfdasxzcvzdfsafdzcbvzfdsafdsfavcxzv";
		//定义一个Map存储<字符,次数>
		Map< Character, Integer>  map = new HashMap<>();
		
		//遍历字符串中的每个字符
		for( int i = 0 ; i < text.length(); i++){
			char cc = text.charAt(i);
			//如果这个字符是第一次出现, map中的键不包含这个字符, 把<字符,1>添加到map中
			if ( ! map.containsKey(cc) ) {
				map.put(cc, 1);
			}else{
				//如果字符不是第一次出现, 把map中该字符的次数返回, 加1 , 再存到map中
				int count = map.get(cc);
				map.put(cc, count+1 );
			}
		}
		//打印 结果
		Set<Entry<Character, Integer>> entrySet = map.entrySet();
		for (Entry<Character, Integer> entry : entrySet) {
			System.out.println(entry.getKey() + " : " + entry.getValue());
		}
	}

}
a : 8
b : 1
s : 6
c : 3
d : 7
f : 9
v : 4
x : 2
z : 5

Process finished with exit code 0

5.3 HashMap工作原理

在这里插入图片描述

5.4 HashMap与HashTable

  1) HashTable底层是哈希表, 它是线程安全的 , HashMap不是线程安全的
  2) HashTable默认初始化大小 :11 HashMap默认初始化大小: 16
   3) 加载因子: 0.75 , 当<键,值>对的数量 大于 数组的容量 * 加载因子时, 数组扩容
   4) HashTable默认扩容: 2倍 + 1 , HashMap扩容: 2倍大小
   5) HashTable的键与值都不能为null, Hashmap的键与值都可以为null
   6) HashTable与HashMap都可以指定初始化容量, HashMap会把容量自动调整为2的幂次方, HashTable不调整

6 Properties

  1)继承了HashTable
  2)键与值都是String类型
  3)用于设置/读取系统属性

public class Test05 {

	public static void main(String[] args) {
		//创建Propertiers,
		Properties properties = new Properties(); 
		
		//设置系统属性
		properties.setProperty("username",  "bjpowernode");
		properties.setProperty("password", "666");
		
		//读取属性值
		System.out.println( properties.getProperty("username"));
		System.out.println( properties.getProperty("password"));
		
	}

}

6.1 读取.properties配置文件1

/**
 * 1) 经常把系统属性保存在配置文件中
 * 2) 一般情况下, 会单独的创建一个资源包, 在该资源包中添加一个配置文件, 配置文件后缀名是.properties
 * 3) 通过Properties读取配置文件中的属性
 */
public class Test06 {

	public static void main(String[] args) throws IOException {
		//1)创建Properties
		Properties properties = new Properties();
		//2) 通过Properties加载配置文件的内容
//		InputStream in = Test06.class.getResourceAsStream("/com/resources/config.properties");
		InputStream in = Thread.currentThread().getContextClassLoader().getResourceAsStream("com/resources/config.properties");		
		properties.load( in );
		
		//3) 读取属性
		System.out.println( properties.getProperty("username"));
		System.out.println( properties.get("password") );
		
	}

}

6.2 读取.properties配置文件2

/**
 * 经常使用ResouceBundle读取配置文件
 *
 */
public class Test07 {

	public static void main(String[] args) {
		//不需要斜杠开头, 也不需要配置文件的扩展名(前提是配置文件的扩展名properties写正确)
		ResourceBundle bundle = ResourceBundle.getBundle("com/resources/config");
		System.out.println( bundle.getString("username"));
		System.out.println( bundle.getString("password"));
	}

}

7 TreeMap

  1)TreeMap实现了SortedMap接口,可以根据键自然排序, 要求键必须是可比较的
  2)要么在创建TreeMap时, 指定Comparator比较器,如果没有指定Comparator比较器, 要求键实现Comparable接口
  3)在TreeMap中, 系统先查看是否有Comparator, 没有Comparator的情况下,再看键是否实现了Comparable.
  4)开发时,如何选择使用Comparator还是Comparable??
  5)一般情况下,让键实现Comparable接口定义一个默认的比较规则, 可以通过Comparator定义很多不同的比较规则
在这里插入图片描述

public class Test08 {

	public static void main(String[] args) {
		//创建TreeMap,存储<员工姓名,工资> , 指定Comparator比较器,根据姓名降序排序
		TreeMap<String, Integer> treeMap = new TreeMap<>( new Comparator<String>() {
			@Override
			public int compare(String o1, String o2) {
				return o2.compareTo(o1);
			}
		});
		
		treeMap.put("lisi", 4000);
		treeMap.put("wang", 5000);
		treeMap.put("chen", 7000);
		treeMap.put("zhao", 2000);
		System.out.println( treeMap );
		
		//创建TreeMap时, 如果没有指定Comparator比较器, 要求键实现Comparable接口
		TreeMap<String, Integer> treeMap2 = new TreeMap<>();
		treeMap2.putAll( treeMap );
		System.out.println( treeMap2 ); 
		
	}

}
{zhao=2000, wang=5000, lisi=4000, chen=7000}
{chen=7000, lisi=4000, wang=5000, zhao=2000}

Process finished with exit code 0

8 Collections工具类

  1)java.util.Collections, 提供了对集合的相关操作
  2)在该类中一组方法 synchronizedXXX( xxx ) 可以把xxx集合由不是线程安全的集合转换为线程安全的集合, 如: synchronizedCollection(Collection c), synchronizedMap(Map<K,V> m),
  3) 现在开发多线程程序, 一般使用java.util.concurrent包中线程安全的类:copyOnWriterArrayList, copyOnWriteArraySet, concurrentSkipListSet、concurrentHashMap, concurrentSkipListMap

9 使用

  String url = “https://image.baidu.com/search/index? tn=baiduimage& ct=201326592 &lm=-1&cl=2&ie=gb18030&word=asdfaf&fr=ala&ala=1& alatpl=adress&pos=0& hs=2& xthttps=111111”;
  1)把url中的参数名与参数值保存到Map中
  2)遍历map打印参数与参数值

public class Test01 {

	public static void main(String[] args) {
		String url = "https://image.baidu.com/search/index? tn=baiduimage& ct=201326592 &lm=-1&cl=2&ie=gb18030&word=asdfaf&fr=ala&ala=1& alatpl=adress&pos=0& hs=2& xthttps=111111";
		
		//把url中的参数名与参数值保存到Map中
		//1) 获得参数字符串, 在Url的问号?后面
		int index = url.indexOf("?");
		String parameters = url.substring( index + 1 );
		parameters = parameters.trim(); 		//去掉前后的空白
		System.out.println( parameters );
		
		//2) 把参数字符串分隔
		String[] params = parameters.split("[=&\\s]+");
		System.out.println(Arrays.toString(params));
		
		//3)遍历字符串数组, 分别把参数名与参数值保存到Map中
		Map<String, String> map = new HashMap<>();
		for( int i = 0 ; i<params.length-1 ; i+=2 ){
			map.put( params[i], params[i+1]);
		}
		//4)遍历map
		Set<Entry<String, String>> entrySet = map.entrySet();
		for (Entry<String, String> entry : entrySet) {
			System.out.println( entry.getKey() + " : " + entry.getValue() );
		}
	}

}
tn=baiduimage& ct=201326592 &lm=-1&cl=2&ie=gb18030&word=asdfaf&fr=ala&ala=1& alatpl=adress&pos=0& hs=2& xthttps=111111
[tn, baiduimage, ct, 201326592, lm, -1, cl, 2, ie, gb18030, word, asdfaf, fr, ala, ala, 1, alatpl, adress, pos, 0, hs, 2, xthttps, 111111]
ct : 201326592
lm : -1
xthttps : 111111
pos : 0
ala : 1
cl : 2
tn : baiduimage
hs : 2
ie : gb18030
fr : ala
word : asdfaf
alatpl : adress

Process finished with exit code 0
/**
* 构造一个集合,保存以下数据:
   [
           {
               "fengxiang": "南风",
               "fengli": "3-4级",
               "high": "高温 32℃",
               "type": "多云",
               "low": "低温 17℃",
               "date": "16日星期二"
           },
           {
               "fengxiang": "南风",
               "fengli": "微风级",
               "high": "高温 34℃",
               "type": "晴",
               "low": "低温 19℃",
               "date": "17日星期三"
           },
           {
               "fengxiang": "南风",
               "fengli": "微风级",
               "high": "高温 35℃",
               "type": "晴",
               "low": "低温 22℃",
               "date": "18日星期四"
           }
          
       ]
   遍历集合中的内容, 把集合的内容以字符串的形式打印出来
*
*/
public class Test02 {

   public static void main(String[] args) {
   	//创建一个List集合, 存储Map数据
   	List< Map<String, String> >  list = new ArrayList<>();
   	
   	//创建一个Map,把该Map添加到List集合中
   	Map<String, String> map1 = new HashMap<>();
   	map1.put("fengxiang", "南风");
   	map1.put("fengli", "二级");
   	map1.put("type", "晴");
   	map1.put("date", "18日星期四");
   	list.add(map1);
   	//创建一个Map,把该Map添加到List集合中
   	Map<String, String> map2 = new HashMap<>();
   	map2.put("fengxiang", "北风");
   	map2.put("fengli", "六级");
   	map2.put("type", "阴");
   	map2.put("date", "19日星期五");
   	list.add(map2);
   	//创建一个Map,把该Map添加到List集合中
   	map2 = new HashMap<>();
   	map2.put("fengxiang", "南风");
   	map2.put("fengli", "3级");
   	map2.put("type", "晴");
   	map2.put("date", "20日星期六");
   	list.add(map2);

   	//遍历List集合,根据集合的内容生成一个字符串, List集合的每个元素是一个Map集合, 
   	StringBuilder sb = new StringBuilder();
   	sb.append("[");
   	
   	for( int i = 0 ;  i<list.size() ; i++){
   		//返回List集合的元素, 每个元素是一个Map
   		Map<String, String> map = list.get(i);
   		sb.append("{");
   		//遍历Map的entry
   		Set<Entry<String, String>> entrySet = map.entrySet();
   		for (Entry<String, String> entry : entrySet) {
   			sb.append(entry.getKey());
   			sb.append(" : ");
   			sb.append(entry.getValue());
   			sb.append("\n");
   		}			
   		sb.append("}");
   		//使用逗号分隔
   		if ( i < list.size() - 1 ) {
   			sb.append(",");
   		}
   		sb.append("\n");
   	}
   	sb.append("]");
   	
   	System.out.println( sb );
   }

}
[{date : 18日星期四
fengli : 二级
fengxiang : 南风
type : 晴
},
{date : 19日星期五
fengli : 六级
fengxiang : 北风
type : 阴
},
{date : 20日星期六
fengli : 3级
fengxiang : 南风
type : 晴
}
]

Process finished with exit code 0
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值