java可变参数 map_map集合和可变参数总结

*① Map集合是所有双列集合的根接口,有如下特点:

* 1. 是以键值对的形式存储对象

* 2. 并且key值需要唯一

* 3. 值可以是多个

* 4. 是无序的, 存取的顺序不能保证

*

* 场景成员方法:

1. public V put(K key, V value);// 添加一组键值对,返回被替换的值.

2.public V get(K key);// 根据给定的key获取值

3.public V remove(K key);// 根据key删除键值对.

4.public void clear();//清除所有的键值对

5.public int size();// 获取集合的长度

6.public boolean containerKey(K key);//判断集合是否包含指定的key

7.public boolean containerValue(V value);// 判断集合是否包含指定的value

Map集合中常见的实现类: HashMap, LinkedHashMap, Properties

* 如何遍历Map集合?

* 由于Map集合并没有继承自java.lang.Iterable接口,所以不能使用迭代器和增强for;

* 但是, Map集合中提供了一个方法,keySet, 可以获取到所有key的Set集合.

*

* 获取到所有键的集合方法:

* public set keySet();

*

* Map集合的遍历步骤:

* 1. 使用ketSet方法获取到所有的键的Set集合

* 2. 获取到Set集合的迭代器

* 3. 遍历迭代器,根据key获取到对应的value

* Map集合中提供了第二种遍历方式, 使用Entry内部接口的方式来实现.

* Entry: Map集合的内部接口

* 有两个常用成员方法:

* public K getKey();

* public V getValue();

*

* 使用Entry的方式来遍历Map集合的步骤:

* 1. 创建Map集合

* 2. 添加元素, put

* 3. 调用map集合中的entrySet(), 获取到映射关系对象(结婚证)的Set集合

* 4. 获取到Set集合的迭代器

* 5. 使用增强for循环遍历

*② HashMap集合是Map集合的实现类,特点:

* 1. 完全符合map集合特点(无序,键唯一,值可以多个)

* 2. 可以存储null和null值, 比较少使用

* 3. 底层是通过哈希表实现

* 4. 线程不安全,效率高

1 packagecn.itcast.demo01;2

3

4

5 importjava.util.HashMap;6

7 importjava.util.Iterator;8

9 importjava.util.Map;10

11 importjava.util.Map.Entry;12

13 importjava.util.Set;14

15

16

17 public classDemo05HashMap {18

19

20

21 public static voidmain(String[] args) {22

23

24

25 HashMapmap = new HashMap();26

27 //map.put(null, null);//不能只有key为null28

29

30

31 //添加元素到hashMap集合中

32

33 map.put("AA", 100);34

35 map.put("BB", 200);36

37 map.put("EE", 500);38

39 map.put("CC", 300);40

41 map.put("DD", 400);42

43

44

45 //methodLoop1(map);

46

47 methodLoop2(map);48

49 }50

51

52

53 /*

54

55 * 使用entrySet方式遍历56

57 */

58

59 public static void methodLoop2(Mapmap){60

61 //1.获取到所有的映射关系对象的Set集合

62

63 Set> set =map.entrySet();64

65

66

67 //2.获取到Set集合的迭代器

68

69 Iterator> iter =set.iterator();70

71

72

73 //3.遍历迭代器

74

75 while(iter.hasNext()){76

77 Entry next =iter.next();78

79

80

81 //获取到结婚证的key,value

82

83 String key =next.getKey();84

85 Integer value =next.getValue();86

87 System.out.println(key + "\t"+value);88

89 }90

91 }92

93

94

95 //使用keyset方式进行遍历

96

97 public static void methodLoop1(Mapmap){98

99

100

101 //1.获取到所有的key的Set集合, 使用keySet方法

102

103 Set set =map.keySet();104

105

106

107 //2.获取到迭代器

108

109 Iterator iter =set.iterator();110

111

112

113 //3.遍历迭代器

114

115 while(iter.hasNext()){116

117 String key = iter.next();//获取到key

118

119 Integer value = map.get(key);//获取到value

120

121

122

123 System.out.println(key + "\t" +value);124

125 }126

127

128

129 }130

131 }132

*③ LinkedHashMap是Map集合的一个实现类, 继承自HashMap;

* 特点:

* 1. 符合Map接口的特点(除了无序之外的特点都有)

* 2. 有序, 存取的顺序一致

* 3. 双向链表和哈希表

* 4. 线程不安全,效率高

public classDemo06LinkedHashMap {public static voidmain(String[] args) {//创建Linkedhashmap对象

Mapmap = new LinkedHashMap();//添加元素

map.put(new Cat("Tom"), 100);

map.put(new Cat("Jack"), 200);

map.put(new Cat("Rose"), 300);//使用增强for遍历出来

Set set =map.keySet();for(Cat cat : set) {

Integer value=map.get(cat);

System.out.println(cat+ "\t" +value);

}

}

}

* 为什么使用Map集合存储对象的时候key不能重复.

* key依赖了: hashCode和equals方法

*

* 因为JDK中的String类已经覆盖了Object中的 equals方法和hashCode

* 如果自定义的对象,需要通过内容去判断对象是否是同一个对象,也需要覆盖Object中的equals方法和hashCode方法

*④ Properties类是Map集合的实现类, 继承自HashTable;

* HashTable是JDK1.0的一个集合,线程安全,目前已经弃用;

*

* 但是他的子类Properties依然活跃在开发舞台;

* Properties特点:

* 1. 拥有Map集合的特点

* 2. 类中并没有在创建对象的时候指定泛型, 默认的泛型是String

* 3. 可以配合IO流, 来读取或者存储文件的内容到集合.

* 4. 以后的时候场景: 主要是读取配置文件中的信息到集合中

*

* 提供了常用的成员方法:

1. public String getProperty(String key);// 通过key获取值

2. public Object setProperty(String key, String value);// 设置键值,返回被替换的元素

3. public Set stringPropertyNames();// 获取所有键的集合

4. public void load(InputStream is);// 使用字节流读取文件内容集合

5. public void load(Reader reader);// 使用字符流读取文件内容到集合

packagecn.itcast.demo01;importjava.io.FileNotFoundException;importjava.io.FileReader;importjava.io.IOException;importjava.io.Reader;importjava.util.Properties;importjava.util.Set;/** 将文件中的内容读取到集合中Properties

* public void load(Reader reader);// 使用字符流读取文件内容到集合*/

public classDemo09LoadFileToProperties {public static void main(String[] args) throwsIOException {//1.创建Properties对象

Properties p= newProperties();//2.调用load方法加载IO的内容到集合中

Reader r= new FileReader("abc.properties");

p.load(r);//3.遍历集合, stringPropertyName();获取到所有键的Set集合

Set set =p.stringPropertyNames();for(String key : set) {//通过key获取到value

String value=p.getProperty(key);

System.out.println(key+ "\t" +value);

}//关闭流释放资源

r.close();

}

}

packagecn.itcast.demo01;importjava.io.FileWriter;importjava.io.IOException;importjava.io.Writer;importjava.util.Properties;/** 将集合Properties中的内容,存储到文件中;

* public void store(Writer writer, String comments);

* writer: 表示需要传入一个字符输出流

* comments: 就是一个描述信息*/

public classDemo10StorePropertiesToFile {public static void main(String[] args) throwsIOException {//1.创建Properties对象

Properties p= newProperties();//2.添加元素

p.setProperty("name", "Tom");

p.setProperty("age", "13");

p.setProperty("address", "BeiJing");//3.将集合中的内容存储到文件中

Writer w= new FileWriter("abc2.properties");

p.store(w,"welcome to Here");//4.关闭流,释放资源

w.close();

}

}

* 可变参数: 写在方法参数当中的类型, 本质上就是一额数组

package cn.itcast.demo01;

/*

*

* 特点:

* 1. 格式: 数据类型 ... 变量名;// 必须是三个点,

* 2. 使用的使用, 传入的是同种数据类型的多个元素, 可以是0-n个

* 3. 作用: 就是对数组的简化使用

*

* 注意点:

* 1. 不能在同一个方法中写两个可变参数

* 2. 如果有多个参数需要传递, 那么可变参数需要写在最后面

*/

public classDemo11VariablePara {public static voidmain(String[] args) {//可以传入0-n个数字//method();//method(10);

method(10,20,30);//method2(10,20,30);

method3(10,20,30);int[]array = {1,2,3,4};

method3(100,array);

}public static void method(int...a){//等价于 int[]a

for (int i = 0; i < a.length; i++) {

System.out.println(a[i]);

}

}//1. 不能在同一个方法中写两个可变参数//public static void method2(int...a, int ...b){//}//2. 如果有多个参数需要传递, 那么可变参数需要写在最后面

public static void method3(int a,int...array){

}

}

* Collections类

packagecn.itcast.demo01;importjava.util.ArrayList;importjava.util.Collections;importjava.util.Comparator;importjava.util.List;/** Collections类, 工具类, 构造方法已经被私有化了

* 所以提供了一些常见的静态方法:

* public static void shuffle(List> list);// 将List集合乱序

* public static void sort(List list);// 排序List集合, 默认升序, 使用的是ASCII/Unicode

*

* 补充如何降序:

* 需要使用方法: public static void sort(List>list, Comparator c);

**/

public classDemo12Collections {public static voidmain(String[] args) {//methodShuffle();//methodSort();

methodDesSort();

}//扩展降序: ort(List>list, Comparator c);

public static voidmethodDesSort() {//1.定义List集合

List list = new ArrayList();//2.添加元素

list.add("BBB");

list.add("AAA");

list.add("DDD");

list.add("CCC");//3.降序

Comparator c = new Comparator() {

@Overridepublic intcompare(String o1, String o2) {returno2.compareTo(o1);

}

};

Collections.sort(list, c);

System.out.println(list);

}//sort(List list);//排序List集合, 默认升序

public static voidmethodSort() {//1.定义List集合

List list = new ArrayList();//2.添加元素

list.add("BBB");

list.add("AAA");

list.add("DDD");

list.add("CCC");

Collections.sort(list);

System.out.println(list);

}//shuffle(List> list);//将List集合乱序

public static voidmethodShuffle(){//1.定义List集合

Listlist = new ArrayList();//2.添加元素

list.add("AAA");

list.add("BBB");

list.add("CCC");

list.add("DDD");

System.out.println(list);//[AAA, BBB, CCC, DDD]

Collections.shuffle(list);//打乱顺序

System.out.println(list);//[AAA, BBB, DDD, CCC]

}

}