Java学习第四十三天＜LinkedHSet＞＜Map接口＞＜HMap小结＞＜HMap底层机制＞＜HMap扩容树化触发＞＜Htable＞<集合选型规则><TreeSet/Map><工具类>
LinkedHashSet
package chapter17.Set;
import java.util.LinkedHashSet;
import java.util.Set;
public class LinkedHashSetSource {
public static void main(String[] args) {
Set set = new LinkedHashSet();
set.add(new String("AA"));//第一次添加时扩容到16
set.add(456);
set.add(456);//无
set.add(new Customer("刘",1001));
set.add(123);
set.add("ggg");
System.out.println(set);//有顺序
}
}
class Customer{
private String name;
private int no;
public Customer(String name, int no) {
this.name = name;
this.no = no;
}
}
package chapter17.Set;
import java.util.LinkedHashSet;
import java.util.Objects;
public class LinkedHashSetExercise {
public static void main(String[] args) {
LinkedHashSet linkedHashSet = new LinkedHashSet();
boolean xx = linkedHashSet.add(new Car("xx", 1000));
boolean xx2 = linkedHashSet.add(new Car("xx", 1000));//无
boolean xx3 = linkedHashSet.add(new Car("y", 1000));
System.out.println(linkedHashSet);
}
}
class Car{
private String name;
private double price;
public Car(String name, double price) {
this.name = name;
this.price = price;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Car car = (Car) o;
return Double.compare(car.price, price) == 0 && Objects.equals(name, car.name);
}
@Override
public int hashCode() {
return Objects.hash(name, price);
}
@Override
public String toString() {
return "Car{" +
"name='" + name + '\'' +
", price=" + price +
'}';
}
}
Map接口
package chapter17.Map;
import com.sun.javafx.collections.MappingChange;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Map01 {
public static void main(String[] args) {
// Map 存放Key-Value存放双列元素
Map map = new HashMap();
map.put("1","xx");
map.put("2","yy");
System.out.println(map);//无序的，根据key的哈希值排序
map.put("1","zz");
System.out.println(map);//k相同时会替换 k-V都相同则无效
map.put(null,null);
System.out.println(map);//K-V可以为空
System.out.println(map.get(null));//get方法返回key对应的value
Set set = map.entrySet();//为方便遍历会创建EntrySet集合封装K-V Node<k，V>继承了Map.Entry 把HashMap里的Node存到entrySet，会有得到重要方法get K,V
System.out.println(set.getClass());
System.out.println(set);
for (Object o :set) {
Map.Entry entry=(Map.Entry) o;
System.out.println(entry.getKey()+"-"+entry.getValue());
}
Set set1 =map.keySet();//封装K的组合
System.out.println(set1);
Collection values = map.values();
System.out.println(values);//封装V的组合
}
}
Map接口方法
package chapter17.Map;
import java.util.HashMap;
import java.util.Map;
public class MapMethod {
public static void main(String[] args) {
Map map = new HashMap();
map.put("xx",new A("TT"));
map.put("xx","yy");//替换
map.put("yy","zz");
System.out.println(map);//{xx=yy, yy=zz}
System.out.println(map.get("xx"));//yy
System.out.println(map.size());//2
System.out.println(map.isEmpty());//F
System.out.println(map.containsKey("yy"));//T 有没有存在
map.clear();//清空
System.out.println(map);//{}
}
}
class A{
private String name;
public A(String name) {
this.name = name;
}
}
Map六大遍历方式
package chapter17.Map;
import java.util.*;
//map六大遍历
public class MapFor {
public static void main(String[] args) {
Map map = new HashMap();
map.put("1","xx");
map.put("2","yy");
map.put("3",null);
map.put("4","yy");
map.put(null,"yy");
//取出K 通过K取出对应V
Set set = map.keySet();
System.out.println("==============");//1.增强for
for (Object o :set) {
System.out.println(o+"-"+map.get(o));
}
System.out.println("==============");//2.迭代器
Iterator iterator=set.iterator();
while (iterator.hasNext()) {
Object next = iterator.next();
System.out.println(next+"-"+map.get(next));
}
//直接取出values
System.out.println("==============");//3.直接v 增强for
Collection values = map.values();
for (Object o :values) {
System.out.println(o);
}
System.out.println("==============");//4.直接v 迭代器
Iterator iterator1 = values.iterator();
while (iterator1.hasNext()) {
Object next = iterator1.next();
System.out.println(next);
}
//用entryset获取k-v
System.out.println("==============");//5.增强for
Set set1 = map.entrySet();
for (Object o :set1) {
Map.Entry m=(Map.Entry)o;
System.out.println(m.getKey()+"-"+m.getValue());
}
System.out.println("==============");//6.迭代器
Iterator iterator2 = set1.iterator();
while (iterator2.hasNext()) {
Object next = iterator2.next();//运行类型是HashMap的Node 要转成MapEntry
Map.Entry m=(Map.Entry)next;
System.out.println(m.getKey()+"-"+m.getValue());
}
}
}
Map练习
package chapter17.Map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapExercise {
public static void main(String[] args) {
HashMap hashMap = new HashMap();
hashMap.put("1",new Employee(1,"xx",100));
hashMap.put("2",new Employee(2,"yy",528527));
hashMap.put("3",new Employee(3,"zz",145247));
Set set1 = hashMap.keySet();
for (Object o :set1) {
Employee employee = (Employee) hashMap.get(o);//向下转拿到sal
if (employee.getSal()>18000){
System.out.println(employee);
}
}
System.out.println("=========");
Set set = hashMap.entrySet();
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
Map.Entry next = (Map.Entry)iterator.next();//next转型后可拿到Value对象
Employee m=(Employee)next.getValue();//对V对象转型拿到sal 而不是对next（entry）转型
if (m.getSal()>18000){
System.out.println(m);
}
}
}
}
class Employee{
private int id;
private String name;
private double sal;
public Employee(int id, String name, double sal) {
this.id = id;
this.name = name;
this.sal = sal;
}
public double getSal() {
return sal;
}
@Override
public String toString() {
return "Employee{" +
"id=" + id +
", name='" + name + '\'' +
", sal=" + sal +
'}';
}
}
HMap小结
HMap底层机制
package chapter17.Map;
import java.util.HashMap;
public class HashMapSource {
public static void main(String[] args) {
HashMap map = new HashMap();
map.put("java",10);
map.put("php",10);
map.put("java",20);//修改
System.out.println(map);
}
}
HMap扩容树化触发
package chapte17.Map;
import java.util.HashMap;
//扩容树化触发
public class HashMapSource2 {
public static void main(String[] args) {
HashMap hashMap = new HashMap();
for (int i = 1; i <=12 ; i++) {
hashMap.put(new A1(i),"hello");
}
System.out.println(hashMap);//没有重写equals，有12个对象，是链表树化
}
}
class A1{
private int num;
public A1(int num) {
this.num = num;
}
//所有A对象hashcode都是100
@Override
public int hashCode() {
return 100;
}
@Override
public String toString() {
return "\nA1{" +
"num=" + num +
'}';
}
}
Hashtable
package chapter17.Map;
import java.util.Hashtable;
public class HashTable01 {
public static void main(String[] args) {
Hashtable hashtable = new Hashtable();
hashtable.put("john",100);
// hashtable.put(null,100);//异常
// hashtable.put("john",null);//异常
hashtable.put("lucy",100);
hashtable.put("lic",100);
hashtable.put("lic",88);//替换
System.out.println(hashtable);
/*
1. 底层数组 Hashtable$Entry[] 初始化11个空间
2. 扩容临界值11*0.75=8 扩到23个
*/
}
}
properties
package chapter17.Map;
import java.util.Properties;
public class Properties01 {
public static void main(String[] args) {
Properties properties = new Properties();
//继承hashtable K-V存放 不能为null
properties.put("xx",100);
properties.put("yy",100);
properties.put("zz",100);
properties.put("zz",80);//换
System.out.println(properties);//{zz=80, xx=100, yy=100}
System.out.println(properties.get("xx"));//100
}
}
集合选型规则
TreeSet
package chapter17.Tree;
import java.util.Comparator;
import java.util.TreeSet;
public class TreeSet01 {
public static void main(String[] args) {
// TreeSet treeSet = new TreeSet();
TreeSet treeSet =new TreeSet(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
// return ((String)o1).compareTo((String)o2);//字符串大小比较
return ((String)o1).length()-((String)o2).length();//字符串长度比较 一样则加不进
}
});
treeSet.add("xx");
treeSet.add("yy");
treeSet.add("zz");
treeSet.add("dd");
System.out.println(treeSet);//当用无参构造器创建TreeSet 仍然是无序的
}
}
TreeMap
package chapter17.Tree;
import java.util.Comparator;
import java.util.TreeMap;
public class TreeMap01 {
public static void main(String[] args) {
// TreeMap treeMap = new TreeMap();
TreeMap treeMap = new TreeMap(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
return ((String)o1).compareTo((String)o2);//若比长度，长度一致也加不进
}
});
treeMap.put("xx",55);
treeMap.put("aa",56);
treeMap.put("tt",57);
treeMap.put("hhh",58);
System.out.println(treeMap);//当用无参构造器创建TreeSet 仍然是无序的
}
}
Collections工具类
package chapter17.Collection工具类;
import java.util.*;
public class Collections01 {
public static void main(String[] args) {
List list = new ArrayList();
list.add("xx");
list.add("yy");
list.add("zz");
list.add("ff");
Collections.reverse(list);//元素反转
System.out.println(list);
Collections.shuffle(list);//随机打乱
System.out.println(list);
Collections.sort(list);//自然排序
System.out.println(list);
Collections.sort(list, new Comparator() {//按字符串长度
@Override
public int compare(Object o1, Object o2) {
return ((String)o1).length()-((String)o2).length();
}
});
System.out.println(list);
Collections.swap(list,0,1);//指定位置交换
System.out.println(list);
System.out.println(Collections.max(list));//自然顺序最大元素
System.out.println(Collections.max(list, new Comparator() {//长度最大元素
@Override
public int compare(Object o1, Object o2) {
return ((String)o1).length()-((String)o2).length();
}
}));
System.out.println(Collections.frequency(list,"xx"));//出现频率
ArrayList dest = new ArrayList();
for (int i = 0; i <list.size() ; i++) {//两个size要一致，不然拷贝会报错
dest.add("");
}
Collections.copy(dest,list);//list 复制到 dest
System.out.println(dest);
Collections.replaceAll(dest,"xx","XX");//替换元素
System.out.println(dest);
}
}
浙公网安备 33010602011771号