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<K> keySet();

 * 

 * Map集合的遍历步骤:

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

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

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

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

 * Entry<K, V>: 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. 线程不安全,效率高

 package cn.itcast.demo01;

 

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

 

public class Demo05HashMap {

 

public static void main(String[] args) {

 

HashMap<String, Integer>map = new HashMap<String, Integer>();

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

 

// 添加元素到hashMap集合中

map.put("AA", 100);

map.put("BB", 200);

map.put("EE", 500);

map.put("CC", 300);

map.put("DD", 400);

 

//methodLoop1(map);

methodLoop2(map);

}

 

/*

* 使用entrySet方式遍历

*/

public static void methodLoop2(Map<String, Integer>map){

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

Set<Entry<String, Integer>> set = map.entrySet();

 

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

Iterator<Entry<String, Integer>> iter = set.iterator();

 

//3.遍历迭代器

while(iter.hasNext()){

Entry<String, Integer> next = iter.next();

 

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

String key = next.getKey();

Integer value = next.getValue();

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

}

}

 

// 使用keyset方式进行遍历

public static void methodLoop1(Map<String, Integer>map){

 

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

Set<String> set = map.keySet();

 

//2.获取到迭代器

Iterator<String> iter = set.iterator();

 

//3.遍历迭代器

while(iter.hasNext()){

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

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

 

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

}

 

}

}

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

 * 特点:

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

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

 * 3. 双向链表和哈希表

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

 public class Demo06LinkedHashMap {

 

public static void main(String[] args) {

 

//创建Linkedhashmap对象

Map<Cat, Integer>map = new LinkedHashMap<Cat, Integer>();

 

//添加元素

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

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

map.put(new Cat("Rose"), 300);

 

//使用增强for遍历出来

Set<Cat> set = map.keySet();

 

for (Cat cat : set) {

Integer value = map.get(cat);

 

System.out.println(cat + "	" + 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<String> stringPropertyNames();// 获取所有键的集合

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

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

package cn.itcast.demo01;

 

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.IOException;

import java.io.Reader;

import java.util.Properties;

import java.util.Set;
/*

 * 将文件中的内容读取到集合中Properties

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

 */

public class Demo09LoadFileToProperties {

 

public static void main(String[] args) throws IOException {

//1.创建Properties对象

Properties p = new Properties();

 

//2.调用load方法加载IO的内容到集合中

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

p.load(r);

 

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

Set<String> set = p.stringPropertyNames();

 

for (String key : set) {

// 通过key获取到value

String value = p.getProperty(key);

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

}

 

//关闭流释放资源

r.close();

 

}

}

 

package cn.itcast.demo01;

 

import java.io.FileWriter;

import java.io.IOException;

import java.io.Writer;

import java.util.Properties;

 

/*

 * 将集合Properties中的内容,存储到文件中;

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

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

 * comments: 就是一个描述信息

 */

public class Demo10StorePropertiesToFile {

 

public static void main(String[] args) throws IOException {

//1.创建Properties对象

Properties p = new Properties();

 

//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 class Demo11VariablePara {

 

public static void main(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类

package cn.itcast.demo01;

 

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;

 

/*

 * Collections类, 工具类, 构造方法已经被私有化了

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

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

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

 * 

 * 补充如何降序:

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

 * 

 */

public class Demo12Collections {

 

public static void main(String[] args) {

//methodShuffle();

//methodSort();

methodDesSort();

}

 

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

public static void methodDesSort() {

// 1.定义List集合

List<String> list = new ArrayList<String>();

 

// 2.添加元素

list.add("BBB");

list.add("AAA");

list.add("DDD");

list.add("CCC");

 

//3.降序

Comparator<String> c = new Comparator<String>() {

@Override

public int compare(String o1, String o2) {

return o2.compareTo(o1);

}

};

 

Collections.sort(list, c);

 

System.out.println(list);

 

}

 

// sort(List<T> list);// 排序List集合, 默认升序

public static void methodSort() {

// 1.定义List集合

List<String> list = new ArrayList<String>();

 

// 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 void methodShuffle(){

//1.定义List集合

List<String>list = new ArrayList<String>();

 

//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]

 

}

}