Java-1

增强for循环

• 格式

public class Test {
    public static void main(String[] args) {
        int[] a={1,2,3,4};
        for (int i : a) {
            System.out.println(i);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        for(int i : list){
            System.out.println(i);
        }
    }
}

增强for的内部是一个iterator迭代器

数据结构

数据结构是计算机存储，组织数据的方式。是指相互之间存在一种或多种特定关系的数据元素的集合

通常情况下，精心选择的数据结构可以帮助带来更高的运行与存储效率

常见数据结构之栈

栈是一种数据先进后出的模型

常见数据结构之队列

常见数据结构之数组

查询效率高，增删慢

常见数据结构之链表

链表的每个元素被称为节点，节点有地址，数据，下一个节点的地址
对比数组而言，增删快，查询慢（对比数组而言）

List集合子类特点

1. ArrayList：底层结构是数组
2. LinkedList：底层结构是链表

LinkedList特有的方法

• addFirest：在最前面添加一个元素
• addLast：在最后添加一个元素
• getFirst：返回列表中第一个元素
• getLast：返回列表中最后一个元素
• removeFirst：从列表中删除并返回第一个元素
• removeList：从列表中删除并返回最后一个元素

set（接口）

不包含重复元素的集合，没有带索引的方法，不能使用for循环遍历
子类：HashSet，对集合的迭代顺序不做任何保证

哈希值

• 哈希值不是数据的地址值
• 哈希值是一个int类型的数值

Object类中有个方法，可以返回对象的哈希值

同一个对象多次调用HashCode（）返回的哈希值相同，默认情况下，不同对象调用HashCode（）返回的哈希值不同，而重写hashcode方法可以使其相同

HashSet

HashSet底层结构是hash表
通过源码分析为什么hashset可以保证元素的唯一性

public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }
//put方法
public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
  //hash方法
  static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }
//putVal,hash值是通过元素的hahCode方法得到的
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //如果hash表是否进行初始化，如果没有初始化就将其初始化
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
         //根据对象的哈希值计算元素的存贮位置，如果该位置没有元素，就存贮元素
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            /*
						存入元素与以前的元素比较哈希值
						如果哈希值不同，会继续向下执行将元素添加到集合
						如果哈希值相同，会调用对象的equals方法进行比较
							如果返回false，说明元素不重复
							如果返回true，说明元素重复，不存储
					*/
            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;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

LinkedHashSet

它与HashSet相比可以保证数据的有序性

TreeSet

• 元素有序，这里的顺序不是指的是存储与取出的顺序，而是按照一定的规则进行排序，具体的排序方法取决于构造方法
• TreeSet（）：根据其元素点的自然顺序进行排序
• TreeSet（Comparator comparator）：根据指定的比较器进行排序
• 不能使用普通for循环
  

练习代码：

import java.util.*;

public class Test {
    public static void main(String[] args) {
        TreeSet<Student> treeSet =  new TreeSet<>();
        Student s1 = new Student(19,"cky");
        Student s2 = new Student(20,"lsy");
        Student s3 = new Student(19,"sml");
        Student s4 = new Student(19,"b");
        Student s5 = new Student(19,"b");

        treeSet.add(s2);
        treeSet.add(s3);
        treeSet.add(s1);
        treeSet.add(s4);
        treeSet.add(s5);
        for(Student S : treeSet){
            System.out.println(S.getAge()+","+S.getName());
        }
    }
}
//在使用的时候必须实现Comparable接口，否则会报错
public class Student implements Comparable<Student>{
    private Integer age ;
    private String name ;

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

    public Integer getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    @Override
    public int compareTo(Student o) {
        /*
        * return 0;认为是相同元素不添加
        * return 1;认为是降序
        * return -1;认为是升序
        * */
        int num = o.age - this.age;
        //String里面实现了Compare接口
        int num1= num==0?this.name.compareTo(o.name):num;
        return num1;
    }
}