Java 常用集合类学习
1 Collection集合
1.1 Collection集合简介
集合是用来存储引用类型数据的容器, 注意,集合不能存储基本类型数据
集合分类两类:
1)Collection集合, 是单个存储数据
2)Map集合,是按<键,值>对的形式存储数据, <”张三”, 28> <”李四”, 30>
java.util.Collection集合框架
1.2 Collection集合基本操作
| 返回值类型 | 说明 |
|---|---|
| boolean | add(E e) 向集合中添加元素e |
| boolean | addAll(Collection<? extends E> c) 把参数集合c中的所有元素添加到当前集合中 |
| void | clear() 清空集合中所有元素. |
| boolean | contains(Object o) 判断当前集合是否包含指定的元素o |
| boolean | isEmpty() 判断当前集合是否为空. |
| Iterator | iterator() 返回集合的迭代器 |
| boolean | remove(Object o) 在集合中删除第一个与o匹配的元素 |
| int | size() 返回集合中元素的个数. |
| 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集合的常用操作
| 返回值类型 | 操作 |
|---|---|
| void | clear() 清空 |
| boolean | containsKey(Object key) 判断当前Map中是否包含指定的键 |
| boolean | containsValue(Object value) 判断是否包含指定的值 |
| Set<Map.Entry<K,V>> | entrySet() 返回Entry的集合, 一个<键,值>对就是一个Entry. |
| boolean | equals(Object o) |
| V | get(Object key) 返回指定的键对应的值 |
| boolean | isEmpty() 判断是否为空. |
| Set | keySet() 返回所有键的集合. |
| V | put(K key, V value) 添加<key,value>键值对, 如果键已存在,使用value值替换原来的值 |
| void | putAll(Map<? extends K,? extends V> m) 把m集合中所有的<键,值>对添加到当前集合中 |
| V | remove(Object key) 删除指定键对应的<键,值>对 |
| default boolean | remove(Object key, Object value) |
| int | size() 返回键,值对的数量 |
| Collection | values() 返回所有值的集合 |
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
扫一扫
1624
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
