Java--集合--家庭作业&总结

package com.model.work;

import java.util.ArrayList;
import java.util.Collections;

/**
 * @Description:测试类
 * @Author: 张紫韩
 * @Crete 2021/6/16 14:49
 */
public class TestDemo01 {
    public static void main(String[] args) {
        News news = new News("新型冠状病毒病例超千万，数百万印度教信徒赴恒河\"圣浴\"引民众担忧");
        News news1 = new News("男子突然想起两个月前钓鱼的鱼还在鱼兜里，捞起一看赶紧放生");

        ArrayList<News> list = new ArrayList<>();
        list.add(news);
        list.add(news1);
        Collections.reverse(list);
       for (News obj:list){
           System.out.println(setTitle(obj.getTitle()));
       }

    }
    public static String setTitle(String title){
        if (title==""){
            return null;
        }
        if (title.length()>15){
            return title.substring(0,15)+".....";

        }else {
            return title;
        }
    }
}
class News{
    private String title;
    private String text;

    public News(String title) {
        this.title = title;
    }

    @Override
    public String toString() {
        return "News{" +
                "title='" + title + '\'' +
                '}';
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getText() {
        return text;
    }

    public void setText(String text) {
        this.text = text;
    }
}

package com.model.work;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

/**
 * @Description:测试类
 * @Author: 张紫韩
 * @Crete 2021/6/16 15:20
 */
public class TestDemo02 {
    public static void main(String[] args) {

        ArrayList<Car> list = new ArrayList<>();
        Car car1 = new Car("a", 67.6f);
        Car car2 = new Car("b", 67.6f);
        list.add(car1);
        list.add(car2);
        System.out.println("删除car1："+list.remove(car1));
        System.out.println("查看Car2是否存在："+list.contains(car2));
        System.out.println("查看list中的元素个数"+list.size());
        System.out.println("查看list是否为空："+list.isEmpty());
        list.clear();
        ArrayList<Car> list1 = new ArrayList<>();
        list1.add(car1);
        list1.add(car2);
        System.out.println("添加了多个元素："+list.addAll(list1));
        System.out.println("查看多个元素是否存在："+list.containsAll(list1));
        System.out.println("删除了多个元素："+list.removeAll(list1));
        list.addAll(list1);

        for (Car car:list){
            System.out.println(car.toString());
        }
        Iterator<Car> iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next().toString());
        }



    }
}
class Car{
    private String name;
    private Float price;

    public String getName() {
        return name;
    }

    public Car(String name, Float price) {
        this.name = name;
        this.price = price;
    }

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

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

    public Float getPrice() {
        return price;
    }

    public void setPrice(Float price) {
        this.price = price;
    }
}

package com.model.work;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 * @Description:测试类
 * @Author: 张紫韩
 * @Crete 2021/6/16 15:37
 */
public class TestDemo03 {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("jack", 650);
        map.put("tom", 1200);
        map.put("smith", 2900);

        map.put("jack", 1200);
   /*     for (String key:map.keySet()){
            map.put(key, map.get(key)+100);
        }*/
        for (Map.Entry entry:map.entrySet()){
            Integer value = (Integer) entry.getValue();
            entry.setValue(value+100);
        }
        //Entry集合，迭代器遍历方法
        Set<Map.Entry<String, Integer>> entries = map.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator = entries.iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Integer> next =  iterator.next();
            System.out.println("迭代器遍历所有的员工信息："+next);
        }
        //key集合，迭代器遍历
        Set<String> set = map.keySet();
        Iterator<String> iterator1 = set.iterator();
        while (iterator1.hasNext()) {
            String next =  iterator1.next();
            System.out.println("迭代器遍历所有的员工信息："+next+"="+map.get(next));
        }

        //map.entry方式遍历
        for (Map.Entry entry:map.entrySet()){
            System.out.println("遍历所有的员工"+entry);
        }
        //keySet方式遍历
        for (String key:map.keySet()){
            System.out.println("增强for循环遍历："+key+"="+map.get(key));
        }

        
        for (String key:map.keySet()){
            System.out.println("遍历员工工资："+map.get(key));
        }
        for (Integer val:map.values()){
            System.out.println("遍历员工工资："+val);
        }


        System.out.println(map);
    }
}

package com.model.work;

import java.util.Comparator;
import java.util.HashSet;
import java.util.TreeSet;

/**
 * @Description:测试类
 * @Author: 张紫韩
 * @Crete 2021/6/16 16:14
 */
public class TestDemo04 {
    public static void main(String[] args) {

        TreeSet<Object> treeSet = new TreeSet<>();
        treeSet.add("a");
        treeSet.add("a");
        TreeSet<Object> treeSet1 = new TreeSet<>(new Comparator<Object>() {
            @Override
            public int compare(Object o1, Object o2) {
                return ((String)o1).compareTo(((String)o2));
            }
        });
        treeSet1.add("a");
        treeSet1.add("a");

        /**
         * TreeSet去重机制：
         * 1.这是没有comparator匿名内部类对象是的情况：
         *  else {
         *             if (key == null)
         *                 throw new NullPointerException();
         *             @SuppressWarnings("unchecked")
         *             //将key向上转型为Comparable接口
         *                 Comparable<? super K> k = (Comparable<? super K>) key;
         *             do {
         *                 parent = t;
         *                 //调用Comparable接口的compareTo方法实现对比去重，如果返回为0则代表是一样的就不能进行添加了
         *                 cmp = k.compareTo(t.key);
         *                 if (cmp < 0)
         *                     t = t.left;
         *                 else if (cmp > 0)
         *                     t = t.right;
         *                 else
         *                 //返回值为0直接将替换value，返回结果不在向下执行
         *                     return t.setValue(value);
         *             } while (t != null);
         *         }
         * 2.有匿名内部类对象是：
         *    int cmp;
         *         Entry<K,V> parent;
         *         // split comparator and comparable paths
         *         //获得我们传入的匿名内部类对象
         *         Comparator<? super K> cpr = comparator;
         *         if (cpr != null) {
         *             do {
         *                 parent = t;
         *                 //调用匿名内部类进行比较去重，如果匿名内部类对象返回的值为0则代表来个值相等不能进行添加操作了
         *                 cmp = cpr.compare(key, t.key);
         *                 if (cmp < 0)
         *                     t = t.left;
         *                 else if (cmp > 0)
         *                     t = t.right;
         *                 else
         *                 //直接返回
         *                     return t.setValue(value);
         *             } while (t != null);
         *         }
         *
         * */
        HashSet<Object> hashSet = new HashSet<>();
        hashSet.add("a");
        hashSet.add("a");

        /**
         * HashSet去重机制：
         *      //1.如果 插入节点所在的索引位置为null，则直接将元素放在这个索引的位置
         *    if ((p = tab[i = (n - 1) & hash]) == null)
         *             tab[i] = newNode(hash, key, value, null);
         *         else {
         *             Node<K,V> e; K k;
         *             //1.如果 插入节点所在的索引位置为不为null，则需要对该链表所有的节点进行比较
         *             //比较是通过判断 hash值相等，且==返回true或者equals返回true则代表两个对象一样，则不能进行添加
         *             //注意:我们这里使用的 key.hashCode()和key.equals() 
         *             //方法都是key对象类的方法,所有我们可以通过重写key对象的类的hashCode()和equals() 
         *             //我们认为什么样的对象是相等的，就可以自主实现什么类是相等的（即我们认为名字和年龄相等就就判断两个对象相等）
         *             //他在使用equals方法比较是就会返回true，而它默认的equals方法比较就不一定是相等的。
         *             if (p.hash == hash &&
         *                 ((k = p.key) == key || (key != null && key.equals(k))))
         *                 e = p;
         *             else if (p instanceof TreeNode)
         *                 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
         *             else {
         *                 for (int binCount = 0; ; ++binCount) {
         *                     if ((e = p.next) == null) {
         *                         p.next = newNode(hash, key, value, null);
         *                         if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
         *                             treeifyBin(tab, hash);
         *                         break;
         *                     }
         *                     if (e.hash == hash &&
         *                         ((k = e.key) == key || (key != null && key.equals(k))))
         *                         break;
         *                     p = e;
         *                 }
         *             }
         *
         * */
    }
}

package com.model.work;

import java.util.TreeSet;

/**
 * @Description:测试类
 * @Author: 张紫韩
 * @Crete 2021/6/16 16:18
 */
public class TestDmo05 {
    /**
     * TreeSet中的对象需要实现
     * 1.当没有传入匿名内部类对象comparator时：需要将传入的对象向上 转型为(Comparable<? super K>) 类型，
     *  从而来使用compareTo((K)k2)进行比较去重。
     *  添加第一个元素时：
     *    return comparator==null ? ((Comparable<? super K>)k1).compareTo((K)k2)
     *             : comparator.compare((K)k1, (K)k2);
     * 后面添加元素时：
     *    Comparable<? super K> k = (Comparable<? super K>) key;
     *  2.所以没有传入comparator匿名内部类对象的TreeSet必须实现  Comparable接口这样在转型的时候才不会失败
     *  否则就会抛出异常
     *
     *  3.总结：
     *      1.TreeSet去重机制可以时我们自己实现的Comparator匿名内部类对象，
     *      （当我们创建TreeSet对象是在构造方法中添加一个匿名内部类）
     *      2.如果不添加内名内部类，他会自动调用我们加入类的 向上转型为Comparable接口
     *      （当然能我们加入的key对象不惜实现了Comparable接口）
     *      自动调用Comparator的comparator方法进行方法的去重
     *      3.三种情况吧，要么传入匿名内部类，要么是自动实现Comparable接口的对象（String）
     *      如果都不是我们就需要手动的实现Comparable接口实现compareTo方法

           4.三种比较的返回值如果为0则认为是一样的元素就不能进行添加了



     * */
    public static void main(String[] args) {
        TreeSet<Object> treeSet = new TreeSet<>();
        treeSet.add(new Person());
    }
}
class Person{}

package com.model.work;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Objects;
import java.util.Set;

/**
 * @Description:测试类
 * @Author: 张紫韩
 * @Crete 2021/6/16 17:14
 */
public class TestDemo06 {
    public static void main(String[] args) {

        HashSet<Object> hashSet = new HashSet<>();
        Persons persons=new Persons(1001, "aa");
        Persons persons1=new Persons(1002, "bb");
        hashSet.add(persons1);
        hashSet.add(persons);
        persons.setName("cc");
        hashSet.remove(persons);
        hashSet.add(new Persons(1001,"cc"));//ok ，
        // 是因为，person所在的索引位置应该时 1001 ”aa“的位置，即使他的值改变了但他在table表中的位置是不会改变的，
        //所以我们在接入 1001 ”cc“时，所以索引位置不会有person，没有重复我们就可以进行加入成功
        hashSet.add(new Persons(1001, "aa"));
        //这次添加的索引位置和person的位置一样但是在判断时。他们的值时不一样的，所以他会挂在 person的后面也会添加成功



        //如果重写了hashCode和equals方法就不会删除节点person，
        //因为由于person加入是的值 是1001 ”aa“，我们是根据这个值计算的hash值，的到一个索引的
        //但是当我们删除时他的值变成了1001 ”cc“，这样我们删除时会寻找 1001 ”cc“所在的索引位置，在者个位置循环查找有没有person这个节点，有就删除
        //很显眼我们删除的时候和他插入的顶不是同一个table的索引位置，自然无法找到person，所以删除失败

        //但时如果我们重写hashCode和equals方法，即使person的只改变，也会找到person的索引所在位置进行删除，会删除成功
        System.out.println(hashSet);

    }
}
class Persons{
    private int id;
    private String name;

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public Persons(int id, String name) {
        this.id = id;
        this.name = name;
    }

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

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

1. list接口库容时满了之后才开始扩容
2. map接口的时超过临界值后进行扩容

集合总结：

　　　
Collection
- List
1. - ArrayList
    - 底层　　
  - Vector
  - LinkedList　　
2. Set　　
  - HashSet
  - LinkedHashSet
  - TreeSet　　
Map
1. HashMap
  - LinkedHashMap
2. TreeMap
3. HashTable
  - Properties

package com.model.work;

import java.util.*;

/**
 * @Description:测试类
 * @Author: 张紫韩
 * @Crete 2021/6/16 18:08
 */
public class TestDemo07 {
    public static void main(String[] args) {

        ArrayList<Object> arrayList = new ArrayList<>();
        arrayList.add("a");
        Vector<Object> vector = new Vector<>();
        vector.add("a");

        LinkedList<Object> linkedList = new LinkedList<>();
        linkedList.add("a");
        linkedList.add("b");
        HashSet<Object> hashSet = new HashSet<>();
        hashSet.add("a");
        hashSet.add("a");

        LinkedHashSet<Object> linkedHashSet = new LinkedHashSet<>();
        linkedHashSet.add("a");
        linkedHashSet.add("a");
        TreeSet<Object> treeSet = new TreeSet<>();
        treeSet.add("a");
        treeSet.add("b");

        HashMap<Object, Object> hashMap = new HashMap<>();
        hashMap.put("a", "a");
        hashMap.put("b", "b");
        TreeMap<Object, Object> treeMap = new TreeMap<>();
        treeMap.put("a", "a");

        Hashtable<Object, Object> hashtable = new Hashtable<>();
        hashtable.put("a", "a");

        Properties properties = new Properties();
        properties.put("a", "a");
    }
    /**
     * 集合：
     *     1.Collection
     *             1.List
     *                 * ArrayList
     *                      底层:Object[]类型的数组，构造函数创建一个空数组，第一次加入数据时进行初始化大小为10，按1.5扩容
     *                      可以添加重复的元素，包括null　　
     *                 * Vector
     *                      底层:Object[]类型的数组，构造函数直接创建一个10个空间的数组，当数组满了时，扩容是扩展为原来的2倍
     *                      可以添加重复的元素，包括null
     *                 * LinkedList
     *                      底层：双向链表，是由LinkedList$Node节点构成，初始值0一个一个节点的往上加：节点包括
     *                          E item; 值
     *                          Node<E> next; 指向下一个节点
     *                          Node<E> prev; 指向上一个节点
     *                      可以添加重复的元素，包括null　　
     *             2.Set　　
     *                 * HashSet
     *                      底层：底层时HashMap：数组+链表+红黑树 ，构造函数初始化加载因子，第一次添加是扩容到16，当超过临界值时扩容到原来的2倍
     *                      不允许重复的元素添加，节点时HashMap$Node节点类型
     *
     *                      * LinkedHashSet
     *                          底层是 数组加+双向链表,构造函数直接创建一个长度为16的数组，底层时LinkedHashMap$Entry类型的节点：
     *                          包括 ：before，after，key，value，next
     *                          不允许有重复的元素，插入和取出的顺序一致
     *
     *                 * TreeSet　
     *                      底层是：红黑树 初始大小为o　,节点时TreeMap$Entry类型的包括：
     *                          static final class Entry<K,V> implements Map.Entry<K,V> {
     *                                        K key;
     *                                        V value;
     *                                        Entry<K,V> left;
     *                                        Entry<K,V> right;
     *                                        Entry<K,V> parent;
     *                                        boolean color = BLACK;
     *
     *      2.Map
     *             1.HashMap：
     *                  底层是数组链表红黑树，构造函数初始化加载因子，添加第一个元素是扩容为16，按1.5倍扩容，节点类型HashMap$Node类型：
     *                    Node(int hash, K key, V value, Node<K,V> next) {
     *                           this.hash = hash;
     *                           this.key = key;
     *                           this.value = value;
     *                           this.next = next;
     *                       }
     *                 * LinkedHashMap:
     *                      底层是数组+双向链表LinkedHashMap$Entry类型的接节点：
     *                        static class Entry<K,V> extends HashMap.Node<K,V> {
     *                              Entry<K,V> before, after;
     *                              Entry(int hash, K key, V value, Node<K,V> next) {
     *                              super(hash, key, value, next);
     *                              }
     *                        }
     *
     *             2.TreeMap:
     *                  底层是红黑树，节点类型TreeMap$Entry:
     *                   static final class Entry<K,V> implements Map.Entry<K,V> {
     *                           K key;
     *                           V value;
     *                           Entry<K,V> left;
     *                           Entry<K,V> right;
     *                           Entry<K,V> parent;
     *                           boolean color = BLACK;
     *             3.HashTable:
     *                  底层数据结构：数组链表红黑树，初始大小为11按 2倍加1扩容，线程安全,节点类型是HashTale$Entry;
     *                   private static class Entry<K,V> implements Map.Entry<K,V> {
     *                   final int hash;
     *                   final K key;
     *                   V value;
     *                   Entry<K,V> next;
     *
     *                 * Properties　：底层是HashTable
     *
     *
     *
     *
     * */
}

posted @ 2021-06-16 18:07 张紫韩阅读(49) 评论(0) 编辑收藏举报

刷新页面返回顶部

张紫韩

Java--集合--家庭作业&总结

公告