可变参数
定义：
就是一种特殊形参，定义在方法、构造器的形参列表里，格式是：数据类型...参数名称
特点：
可以不传数据给它；可以传一个或者同时传多个数据给它；也可以传一个数组给它。
好处：
常常用来灵活的接收数据。
注意事项：
-
可变参数在方法内部就是一个数组。
-
一个形参列表中可变参数只能有一个。
-
可变参数必须放在形参列表的最后面。
public static void main(String[] args) { //掌握可变参数的用法。 //可变参数就是一种特殊形参，定义在方法、构造器的形参列表里，格式是：数据类型...参数名称；; test(1); test(1,2,3); } public static void test(int... code){ System.out.println(Arrays.toString(code));//可变参数底层就是数组 System.out.println("----------"); }
Collections
定义:是一个用来操作集合的工具类
Collections提供的常用静态方法:
| 方法名称 | 说明 |
|---|---|
| public static boolean addAll(Collection<? super T> c, T... elements) | 给集合批量添加元素 |
| public static void shuffle(List<?> list) | 打乱List集合中的元素顺序 |
| public static void sort(List list) | 对List集合中的元素进行升序排序 |
| public static void sort(List list，Comparator<? super T> c) | 对List集合中元素，按照比较器对象指定的规则进行排序 |
public class Testd2 {
public static void main(String[] args) {
//掌握Collections工具类操作集合的使用。
// 1、public static <T> boolean addAll(Collection<? super T> c, T...e) 往集合中批量加数据。
List<Integer> list =new ArrayList<>();
Collections.addAll(list,1,2,34,4);
System.out.println(list);
// 2、public static void shuffle(List<?> list)：对集合打乱顺序
Collections.shuffle(list);
System.out.println(list);
// 3.public static <T> void sort(List<T list): 对List集合排序
Collections.sort(list);
System.out.println(list);
// 4、给List集合中的对象进行排序。
List<Girl> lists =new ArrayList<>();
lists.add(new Girl("古力娜扎", 171.5, 46, 30));
lists.add(new Girl("王菲", 168.5, 50, 52));
lists.add(new Girl("杨超越", 167.5, 42, 27));
//Collections只能支持对List集合进行排序
Collections.sort(lists, (Girl o1, Girl o2)-> {
return Double.compare(o1.getHeight(), o2.getHeight());
});
System.out.println(lists);
}
Collections只能支持对List集合进行排序
排序方式1：
| 方法名称 | 说明 |
|---|---|
| public static void sort(List list) | 对List集合中元素按照默认规则排序 |
注意：本方法可以直接对自定义类型的List集合排序，但自定义类型必须实现了Comparable接口，指定了比较规则才可以。
给List集合中的对象进行排序。
List<Girl> lists =new ArrayList<>();
lists.add(new Girl("古力娜扎", 171.5, 46, 30));
lists.add(new Girl("王菲", 168.5, 50, 52));
lists.add(new Girl("杨超越", 167.5, 42, 27));
//Collections只能支持对List集合进行排序
Collections.sort(lists, (Girl o1, Girl o2)-> {
return Double.compare(o1.getHeight(), o2.getHeight());
});
System.out.println(lists);
排序方式2：
| 方法名称 | 说明 |
|---|---|
| public static void sort(List list，Comparator<? super T> c) | 对List集合中元素，按照比较器对象指定的规则进行排序 |
注意：本方法可以直接对自定义类型的List集合排序，但自定义类型必须实现了Comparable接口，指定了比较规则才可以。
@Override
public int compareTo(Girl o) {
if (height>o.height ){
return 1;
}else if (height<o.height){
return -1;
}else {
return this.age;
}
}
Map集合
认识Map集合:
- Map集合称为双列集合，格式：{key1=value1 , key2=value2 , key3=value3 , ...}， 一次需要存一对数据做为一个元素.
- Map集合的每个元素“key=value”称为一个键值对/键值对对象/一个Entry对象，Map集合也被叫做“键值对集合”
- Map集合的所有键是不允许重复的，但值可以重复，键和值是一一对应的，每一个键只能找到自己对应的值
Map集合体系的特点
-
HashMap（由键决定特点）: 无序、不重复、无索引； （用的最多）
-
LinkedHashMap （由键决定特点）:由键决定的特点：有序、不重复、无索引。
-
TreeMap （由键决定特点）:按照大小默认升序排序、不重复、无索引。
注意:Map系列集合的特点都是由键决定的，值只是一个附属品，值是不做要求的
Map的常用方法如下：
| 方法名称 | 说明 |
|---|---|
| public V put(K key,V value) | 添加元素 |
| public int size() | 获取集合的大小 |
| public void clear() | 清空集合 |
| public boolean isEmpty() | 判断集合是否为空，为空返回true , 反之 |
| public V get(Object key) | 根据键获取对应值 |
| public V remove(Object key) | 根据键删除整个元素 |
| public boolean containsKey(Object key) | 判断是否包含某个键 |
| public boolean containsValue(Object value) | 判断是否包含某个值 |
| public Set keySet() | 获取全部键的集合 |
public static void main(String[] args) {
// 1.添加元素: 无序，不重复，无索引。
Map<String,Integer> map = new HashMap<>(); //经典的代码，常用的map
map.put("手表",100);
map.put("手表",200);
map.put("手机",200);
map.put("耳机",300);
map.put(null,null);
System.out.println(map);//{null=null, 手表=200, 手机=200, 耳机=300}
// 2.public int size():获取集合的大小
System.out.println("集合的大小"+map.size());//集合的大小4
// 3、public void clear():清空集合
map.clear();
System.out.println(map);//{}
// 4.public boolean isEmpty(): 判断集合是否为空，为空返回true ,反之！
System.out.println(map.isEmpty());//true
// 5.public V get(Object key)：根据键获取对应值
map.put("手表",100);
map.put("手表",200);
map.put("手机",200);
map.put("耳机",300);
map.put(null,null);
map.get("手表");
map.get("手机");
System.out.println(map);//{null=null, 手表=200, 手机=200, 耳机=300}
// 6. public V remove(Object key)：根据键删除整个元素(删除键会返回键的值)
map.remove("手机");
System.out.println(map);//{null=null, 手表=200, 耳机=300}
// 7.public boolean containsKey(Object key): 判断是否包含某个键 ，包含返回true ,反之
System.out.println(map.containsKey("手表"));//true
// 8.public boolean containsValue(Object value): 判断是否包含某个值。
System.out.println(map.containsValue("null"));//false
System.out.println(map.containsValue("手表"));
// 9.public Set<K> keySet(): 获取Map集合的全部键。
Set<String> set= map.keySet();
System.out.println(set);
// 10.public Collection<V> values(); 获取Map集合的全部值.
Collection<Integer> value1 = map.values();
System.out.println(value1);
// 11.把其他Map集合的数据倒入到自己集合中来。(拓展)
Map<String,Integer> map1 = new HashMap<>();
map1.put("小明",98);
map1.put("小关",78);
map1.put("小光",88);
map1.put("小黑",68);
map1.put("小赵",94);
map1.put("小马",90);
System.out.println("初始值");
System.out.println(map1);
//1.获取Map集合的键和值
Set<String> set1= map1.keySet();
Collection<Integer> value2 = map1.values();
//遍历新的map集合存入键和值
Map<String,Integer> set2 =new HashMap<>();
Iterator<String> it1 =set1.iterator();
Iterator<Integer> it2 =value2.iterator();
while (it1.hasNext()){
set2.put(it1.next(),it2.next());
}
System.out.println("赋给值");
System.out.println(set2);
}
Map集合的遍历方式
1.通过获取map集合的键来获取值，需要用到Map方法有：
| 方法名称 | 说明 |
|---|---|
| public Set keySet() | 获取所有键的集合 |
| public V get(Object key) | 根据键获取其对应的值 |
public static void main(String[] args) {
Map<String, Double> map = new HashMap<>();
map.put("蜘蛛精", 162.5);
map.put("蜘蛛精", 169.8);
map.put("紫霞", 165.8);
map.put("至尊宝", 169.5);
map.put("牛魔王", 183.6);
System.out.println(map);
Set<String> set1 = map.keySet();
for (String s:set1) {
System.out.println(map.get(s));
}
}
2.通过键值对遍历集合
| Map提供的方法 | 说明 |
|---|---|
| Set<Map.Entry<K, V>> entrySet() | 获取所有“键值对”的集合 |
| Map.Entry提供的方法 | 说明 |
| K getKey() | 获取键 |
| V getValue() | 获取值 |
public static void main(String[] args) {
Map<String, Double> map = new HashMap<>();
map.put("蜘蛛精", 169.8);
map.put("紫霞", 165.8);
map.put("至尊宝", 169.5);
map.put("牛魔王", 183.6);
System.out.println(map);
//Set<Map.Entry<K, V>> entrySet() 获取所有“键值对”的集合
Set<Map.Entry<String,Double>> entryes =map.entrySet();
//Map.Entry提供的方法
for (Map.Entry<String,Double> entry: entryes) {
//K getKey() 获取键
String key =entry.getKey();
//V getValue() 获取值
Double value=entry.getValue();
System.out.println(key + "====>" +value);
}
3.Map集合的遍历方式三：Lambda
需要用到Map的如下方法
| 方法名称 | 说明 |
|---|---|
| default void forEach(BiConsumer<? super K, ? super V> action) | 结合lambda遍历Map集合 |
public static void main(String[] args) {
Map<String, Double> map = new HashMap<>();
map.put("蜘蛛精", 169.8);
map.put("紫霞", 165.8);
map.put("至尊宝", 169.5);
map.put("牛魔王", 183.6);
System.out.println(map);
//default void forEach(BiConsumer<? super K, ? super V> action)结合lambda遍历Map集合
map.forEach((key,value)->{
System.out.println(key+"====>>"+value);
});
}
HashMap集合的底层原理
HashMap跟HashSet的底层原理是一模一样的，都是基于哈希表实现的。JDK8之前，哈希表 = 数组+链表 JDK8开始，哈希表 = 数组+链表+红黑树，长度超过8&数组长度>=64，自动转成红黑树
HashMap集合是一种增删改查数据，性能都较好的集合但是它是无序，不能重复，没有索引支持的（由键决定特点）HashMap的键依赖hashCode方法和equals方法保证键的唯一如果键存储的是自定义类型的对象，可以通过重写hashCode和equals方法，这样可以保证多个对象内容一样时，HashMap集合就能认为是重复的。
LinkedHashMap集合的原理
LinkedHashSet集合的底层原理就是LinkedHashMap。底层数据结构依然是基于哈希表实现的，只是每个键值对元素又额外的多了一个双链表的机制记录元素顺序(保证有序)。LinkedHashMap继承自HashMap,它的新增(put)和获取(get)方法都是复用父类的HashMap的代码，只是自己重写了put给get内部的某些接口来搞事情，这个特性在Java里面大家喜欢叫多态，其实多态这个词并不能很好的形容这种现象。其实 LinkedHashMap 几乎和 HashMap 一样：从技术上来说，不同的是它定义了一个 Entry<K,V> header，这个 header 不是放在 Table 里，它是额外独立出来的。LinkedHashMap 通过继承 hashMap 中的 Entry<K,V>,并添加两个属性 Entry<K,V> before,after,和 header 结合起来组成一个双向链表，来实现按插入顺序或访问顺序排序
TreeMap集合的原理
TreeMap跟TreeSet集合的底层原理是一样的，都是基于红黑树实现的排序。TreeMap集合同样也支持两种方式来指定排序规则让类实现Comparable接口，重写比较规则。TreeMap集合有一个有参数构造器，支持创建Comparator比较器对象，以便用来指定比较规则。
TreeMap特点：
不重复、无索引、可排序(按照键的大小默认升序排序，只能对键排序) 原理：TreeMap跟TreeSet集合的底层原理是一样的，都是基于红黑树实现的排序。
