Day07(2020.06.17)

一、LinkedList集合

LinkedList集合的三种遍历

public static void main(String[] args) {
    //创建容器，添加元素
    LinkedList<Integer> l = new LinkedList<>();
    l.add(1);
    l.add(2);
    l.add(3);
    l.add(4);

    //1、普通for循环遍历
    for (int i = 0; i < l.size(); i++) {
        System.out.println(l.get(i));
    }
    System.out.println("=======================");

    //2、增强for循环遍历
    for (Integer i :l) {
        System.out.println(i);
    }
    System.out.println("=======================");

    //3、迭代器循环遍历
    ListIterator<Integer> lit = l.listIterator();
    while (lit.hasNext()){
        System.out.println(lit.next());
    }

    System.out.println("=======================");
    Iterator<Integer> it = l.iterator();
    for(;it.hasNext();){
        System.out.println(it.next());
    }
}

迭代器的使用步骤

1、使用集合中的方法iterator()获取迭代器的实现对象，使用Iterator接口接受（多态）

2、使用Iterator接口中的方法hasNext判断还有没有下一个元素

3、使用Iterator接口中的next方法取出集合中的下一个元素

// 1、使用集合中的方法iterator()获取迭代器的实现对象，使用Iterator接口接受（多态）
//多态  接口            实现类对象
Iterator<String> it = al.iterator();

// 2、使用Iterator接口中的方法hasNext判断还有没有下一个元素
System.out.println(it.hasNext());//true

// 3、使用Iterator接口中的next方法取出集合中的下一个元素
System.out.println(it.next());//小明

//使用迭代器遍历打印出集合中所有元素,使用while
while (it.hasNext()){
    System.out.println(it.next());//小明  小李  小王  小赵
}

//使用迭代器遍历打印出集合中所有元素,for循环
for(Iterator<String> it2 = al.iterator(); it2.hasNext();){
    System.out.println(it2.next());//小明  小李  小王  小赵
}

二、Hashset集合

Set接口的特点:

1. 不允许存储重复的元素
2. 没有索引,没有带索引的方法,也不能使用普通的for循环遍历

HashSet特点:

1. 不允许存储重复的元素
2. 没有索引,没有带索引的方法,也不能使用普通的for循环遍历
3. 是一个无序的集合,存储元素和取出元素的顺序有可能不一致
4. 底层是一个哈希表结构(查询的速度非常的快)

Hashset集合的遍历

1. 增强for循环
2. 迭代器循环

    public static void main(String[] args) {
        //定义一个容器存储同学名，不重名，无序
        HashSet<String> set = new HashSet<>();
        //添加元素
        set.add("张三");
        set.add("李四");
        set.add("王五");
        set.add("张三");

        //增强for循环
        for (String temp: set) {
            System.out.print(temp + " ");//李四 张三 王五
        }

        //迭代器循环
        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            System.out.print(it.next() + " ");//李四 张三 王五
        }
      }

set去重的方法

​ 方法：重写 hashCode与equals方法

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Person person = (Person) o;
    return Objects.equals(name, person.name) &&
            Objects.equals(age, person.age);
}

@Override
public int hashCode() {
    return Objects.hash(name, age);
}

set去重的规律

添加一个对象的时候

(1) 先查看set集合中是否有相同的hash值

​ 如果有，继续查看equals方法

​ 如果没有相同hashCode,直接就认为没有重复的元素，直接添加进去新的元素

(2) 如果equals方法相同，认为已经有了相同的元素，不再添加，否则向容器中添加元素

HashSet存储自定义类型元素

public class Person {
    private String name;
    private Integer age;

    public Person() { }

    public Person(String name, Integer age) { this.name = name; this.age = age; }

    public String getName() {  return name;  }

    public void setName(String name) {  this.name = name;  }

    public Integer getAge() {  return age;  }

    public void setAge(Integer age) { this.age = age; }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return Objects.equals(name, person.name) &&
                Objects.equals(age, person.age);
    }

    @Override
    public int hashCode() {  return Objects.hash(name, age);   }

    @Override
    public String toString() {
        return "Person{" + "name='" + name + '\'' + ", age=" + age + '}';
    }
}

public static void main(String[] args) {
    //创建容器的对象
    HashSet<Person> set = new HashSet<>();
    //添加元素
    Person p1 = new Person("张三1",20);
    Person p2 = new Person("张三2",20);
    Person p3 = new Person("张三3",20);
    Person p4 = new Person("张三1",20);
    set.add(p1);
    set.add(p2);
    set.add(p3);
    set.add(p4);
    //增强for循环遍历容器中存储的元素
    for (Person temp : set) {
        System.out.println(temp);
    }
}

三、HashMap集合

Map接口中定义了很多方法，常用的如下：

• public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
• public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
• public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
• boolean containsKey(Object key) 判断集合中是否包含指定的键。
• public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。
• public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。

public static void main(String[] args) {
    Map<String,Double> map = new HashMap<>();

    // public V put(K key, V value):  把指定的键与指定的值添加到Map集合中。
    map.put("红豆切片面包",9.5);
    map.put("康师傅香辣牛肉面",12.5);
    map.put("百事可乐",3.0);
    map.put("乐事(墨西哥鸡汁番茄味)",6.5);
    map.put("鸡蛋",10.0);
    System.out.println(map);
    //{百事可乐=3.0, 乐事(墨西哥鸡汁番茄味)=6.5, 鸡蛋=10.0, 红豆切片面包=9.5, 康师傅香辣牛肉面=12.5}

    // public V remove(Object k): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
    map.remove("鸡蛋");
    System.out.println(map);
    //{百事可乐=3.0, 乐事(墨西哥鸡汁番茄味)=6.5, 红豆切片面包=9.5, 康师傅香辣牛肉面=12.5}

    // public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
    System.out.println("百事可乐的价格：" + map.get("百事可乐") + "元");//百事可乐的价格：3.0元

    // boolean containsKey(Object key) 判断集合中是否包含指定的键。
    System.out.println(map.containsKey("乐事(墨西哥鸡汁番茄味)"));//true

    // public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。
    Set<String> s = map.keySet();
    System.out.println(s);//[百事可乐, 乐事(墨西哥鸡汁番茄味), 红豆切片面包, 康师傅香辣牛肉面]
}

HashMap集合遍历的六种方法

（第一种方式）键找值方式：即通过元素中的键，获取键所对应的值
分析步骤：
1. 获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键。方法提示:keyset()
2. 遍历键的Set集合，得到每一个键。
3. 根据键，获取键所对应的值。方法提示:get(K key)

// 将所有的key 获取出来放到set集合中，遍历set集合 ， get(key)
Set<Integer> s = map.keySet();
//增强for循环
for (Integer i : s) {
    String v = map.get(i);
    System.out.println(i + "-" + v);
}
System.out.println("------------------------");
//迭代器
Iterator<Integer> it = s.iterator();
while (it.hasNext()){
    Integer k = it.next();
    String v = map.get(k);
    System.out.println(k + "-" + v);
}
System.out.println("============================");

（第二种方式） Entry键值对对象
分析步骤：
1. 获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。方法提示:entrySet()。
2. 遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象。
3. 通过键值对(Entry)对象，获取Entry对象中的键与值。  方法提示:getkey() getValue() 

// 将Map集合中的键值对，利用Entry对象来进行包装，将所有的Entry对象放入一个set集合中
Set<Map.Entry<Integer,String>> s1 =  map.entrySet();
//增强For循环
for(Map.Entry<Integer,String> temp : s1){
    Integer k = temp.getKey();
    String v = temp.getValue();
    System.out.println(k + "-" + v);
}
System.out.println("-------------------------");
//迭代器循环
Iterator<Map.Entry<Integer, String>> it1 = s1.iterator();
while (it1.hasNext()){
    Map.Entry<Integer, String> e = it1.next();
    Integer k = e.getKey();
    String v = e.getValue();
    System.out.println(k + "-" + v);
}
System.out.println("============================");

//获取value值
Collection<String> s2 = map.values();
//增强for循环
for(String temp : s2){
    System.out.println(temp);
}
System.out.println("--------------------------");
//迭代器循环
Iterator<String> it2 = s2.iterator();
while (it2.hasNext()){
    System.out.println(it2.next());
}

四、 Properties

uname=gp
upwd=123456

public static void main(String[] args)throws IOException {
    //创建Properties容器
    Properties properties = new Properties();
    // 加载指定的文件中的内容到 Properties容器中
    properties.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("db.properties"));
    System.out.println(properties.getProperty("uname"));//gp
    System.out.println(properties.getProperty("upwd"));//123456
}