java day13 Set与Map容器

LinkedList

LinkedList 是一种可以在任何位置进行高效地插入和删除操作的有序序列。
LinkedList：底层用双向链表实现的 List。特点：查询效率低，增删效率高，线程不安全。 ArrayList：底层用数
组实现的 List。特点：查询效率高，增删效率低，线程不安全。

手写简单Linkedlist

package day13.linkedlistdemo;
/**
*手写LinkedList的add方法
*	1.定义头节点
*	2.定义LinkedList的大小size
*	3.重写toString方法 用于显示结果
*
*/
public class MyLinkedList {
	//头节点
    private Node head;
    //LinkedList的大小
    private int size;
	//构造函数
    public MyLinkedList() {
    }

	//重写toString()方法
    @Override
    public String toString() {
        StringBuffer s = new StringBuffer();
        Node temp = head;
        while (temp!=null){
            s.append(temp.getData()+" ");
            temp= temp.getNext();
        }
        String s2 = s.toString().substring(0,s.toString().length()-1);
        return "MyLinkedList{" +
                "data=" + s2 +
                ", size=" + size +
                '}';
    }
	//手写LinkedList的add方法 
    public void add(Object object){
    
        Node newNode = new Node(object,null);
        if (null == head){
            head = newNode;
        }else{
            Node temp = head;
            while (temp.getNext() != null){
                temp = temp.getNext();
            }
            temp.setData(object);
        }
        size++;
    }

}
/**
* 节点Node 包含:
* 		1.数据项
* 		2.指向下个节点的地址
*  
* 
* */

class Node{
    private Object data;
    private Node next;

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }

    public Node() {
    }

    public Node(Object data, Node next) {
        this.data = data;
        this.next = next;
    }


}

试着调用

package day13.linkedlistdemo;

public class MyLinkedListDemo {
    public static void main(String[] args) {
        MyLinkedList myLinkedList = new MyLinkedList();
        myLinkedList.add("hhh");
        myLinkedList.add("kkk");
        System.out.println(myLinkedList);
    }
}

Set接口

Set 接口中的元素无序不可重复:不包含重复元素,最多包含一个 null,元素没有顺序 。

HashSet

HashSet是 Set 接口的一个子类，主要的特点是：里面不能存放重复元素，而且采用散 列的存储方法，所以没有 顺序。这里所说的没有顺序是指：元素插入的顺序与输出的顺序不 一致。 使用重写 equals 和 hashcode 来实现自
定义的类型的去重。
Java 中规定，两个内容 相同的对象应该具有相等的
Collection 类对象是否相等对象在调用 remove、contains 等方法时需要比较，这会涉及 到对象类型的 equals 方
法和 hashCode 方法；对于自定义的类型，需要重写 equals 和 hashCode 方法以实现自定义的对象相等规则。

Map接口

实现Map接口的类用来存储键(key)－值(value) 对。
Map 接口的实现类有HashMap和TreeMap等。
Map类中存储的键－值对通过键来标识，所以键值不能重复。
HashMap: 线程不安全，效率高. 允许key或value为null
HashTable:线程安全，效率低. 不允许key或value为null
Properties: HashTable的子类，key和value都是string

HashMap遍历例子

package day13.MapDemo;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.function.DoubleToIntFunction;

public class Demo {
    public static void main(String[] args) {
        Map<Integer,String> map =new HashMap();
        map.put(01,"dll");
        map.put(02,"znj");
        map.put(03,"ygd");

        //第一种遍历 使用keySet
        System.out.println("------keyset-------"    );
        Set<Integer> keySet = map.keySet();
        for (Integer i:keySet){
            System.out.println(i+"--->"+map.get(i));
        }
        //第二种遍历 使用values
        System.out.println("----------values----------");
        Collection<String> s= map.values();
        for (String s1:s){
            System.out.println(s1);
        }
        //第三种遍历 使用entrySet
        System.out.println("--------entrySet----");
        Set<Map.Entry<Integer,String>> set = map.entrySet();
        for (Map.Entry<Integer,String> entry:set){
            System.out.println(entry.getKey() + entry.getValue());
        }
    }
}

比较器

package com.xxxx.compare04;

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

import com.xxxx.entity.Person;

/*
 * 定制比较规则:
 * 	1.内部比较器|自然排序
 * 		要当前比较的类型实现一个借口Comparable接口,重写compareTo方法,方法的内部制定比较规则
 *        硬编码习惯,不够灵活,每次修改源代码
 * 
 * 	2.外部比较器|自定义排序
 * 		使用任何一个实现类实现一个接口Comparator,重写compare方法,方法的内部制定比较规则
 * 
 * 
 * 课后练习: 使用 TreeSet存储Student类型数据,根据姓名比较
 */
public class CompareDemo01 {
	public static void main(String[] args) {
		//默认使用内部比较器
		//TreeSet set1 = new TreeSet();
		//指定使用参数比较器
		//TreeSet(Comparator<? super E> comparator) 
		Comparator<Person> com  = new Hehe();
		//Lambda 
		com  = (Person o1, Person o2)->{
			return o1.getHeight() - o2.getHeight();
		};
		TreeSet set1 = new TreeSet(com);
		set1.add(new Person("李四",19,168));
		set1.add(new Person("卢妹妹",16,172));
		set1.add(new Person("廖廖",17,165));
		
		System.out.println(set1);
		
	}
}

//自定义排序
class Hehe implements Comparator<Person>{

	//根据身高做降序排序
	@Override
	public int compare(Person o1, Person o2) {
		return o2.getHeight() - o1.getHeight();
	}
	
}