API——Day04 Collection，List，迭代器，有序二叉树

Collection.

方法：

add：

   Collection<String> col = new ArrayList<>();
        col.add("鲁智深");

remove：移除元素

Student s3 = new Student("张老三", 34);
        col.remove(s3); // 内部调用equals方法判断对象是否一致

contains：

包含，返回值boolean类型

containsAll：

全部包含，返回值boolean类型

isEmpty：

是否为空

clear：

清空集合

size…,：

集合的大小

iterator：

迭代器

Collection<String> col = new ArrayList<>();
        col.add("鲁智深");
        col.add("西门庆");
        col.add("潘金莲");
        col.add("武大郎");
        col.add("武松");

        Iterator<String> it = col.iterator();
        while (it.hasNext()) {
            // 迭代访问
            String s = it.next();
            // 打印对象
            System.out.println(s);
            // 将s对象删除
//            col.remove(s);
            it.remove();

Collection: toArray

Object[] toArray():无参,返回值类型永远都是Object[],和泛型无关
T[] toArray(T[]):参数->一个具体类型的数组, 作用只是为了提供类型

 Collection<String> arr = new ArrayList<String>();

       arr.add("a");

       arr.add("b");

       arr.add("b");//可以添加重复的对象

       Object[] obj = arr.toArray();//第一种方法

       // String[] str = (String[])arr.toArray();//error

       String[] obj1 = arr.toArray(new String[3]);//第二种方法

针对上面注释的那行代码报错进行分析：

数组不能直接(String[])这样强制将数组变量转换，只有在使用使将元素转换为String，

原因：因为数组是不具体分配内存的，如：String[] x=new String[10];

只有在x[0]=new String("dsgds");时才分配具体内存给对象

例如：

Object[] arr1 = {"man","m","yan"};

       //String[] arrs = (String[])arr1; //error

       for(int i = 0;i <arr1.length;i++){

          System.out.println((String)arr1[i]);

       }

上面的第二种方法就是这样实现的。

Collection: remove

remove(Object o)
原理: 遍历集合, 将每一个元素.equals(o)
contains(Object o)

java.util.Arrays: 数组相关工具类

toString() -> 打印数组内容
sort(arr) -> 数组排序
copyOf() -> 数组复制

asList(arr) -> List 将数组转换成集合

-> 本质上还是数组, 数组长度不可变

 String[] ss = {"张三丰", "张无忌", "谢逊"};
        // 将数组转换为 List 有序列表
        List<String> list = Arrays.asList(ss);
        System.out.println(list);

        // list真正的类型是Arrays的内部类,不是我们真正的ArrayList
        // 不能使用增\删的相关方法
        /*list.add("赵敏");*/
        /*System.out.println(list);*/

        // 让list 变成一个真正的ArrayList
        List<String> list1 = new ArrayList<>(list);
        list1.add("赵敏");
        System.out.println(list1);

java.util.Collections: 集合相关的工具类

sort(List) -> 给List排序, 所有元素必须是可比较的
java.lang.Comparable -> 接口, 可比较的
int compareTo(T t)

Collections.sort(list)

list.sort(null) null -> Comparator
1.列表list -> 数组a
2.Arrays.sort(a, (Comparator) c); c->null
if (c == null) {
sort(a); -> ((Comparable) dest[j-1]).compareTo(dest[j])>0; j–)
} else {
c.compare(pivot, a[mid])
}
Collections.sort(list, new Comparator)
Comparator <? super T>

结论 -
sort: 可以使用自定义比较器Comparator, 元素的类可以没有任何要求
可以不使用比较器, 要求元素的类必须是可比较的Comparable
Comparator: 可以忽略掉本身的比较规则 - compareTo
自定义比较规则

 List<Student> lstu = new ArrayList<>();
        lstu.add(new Student("lucy", 23));
        lstu.add(new Student("jack", 25));
        lstu.add(new Student("tom", 18));
        lstu.add(new Student("zhangsan", 8));
        System.out.println("排序之前: " + lstu);
        // 使用自定义比较器进行排序
        Collections.sort(lstu, new MyComparator());
        System.out.println("排序之后: " + lstu);

import java.util.Comparator;

public class MyComparator implements Comparator<Student> {
    /**
     * 比较 o1 和 o2
     * @return >0   o1 > o2
     *         =0   o1 = o2
     *         <0   o1 < o2
     */
    @Override
    public int compare(Student o1, Student o2) {
        return o1.getAge() - o2.getAge();
    }
}

List

add(index,e)
remove(index)
get(index)
set(index,e)…
List: 特点 -> 有序的[有下标], 允许重复元素
有序: 添加顺序就是访问顺序
排序: 由小到大, 由大到小
List的遍历/迭代: 可以用Iterator
forEach
for

迭代器

1. 迭代器中使用迭代, 然后直接使用 集合.remove(迭代出的元素)
   异常: ConcurrentModificationException
   安全隐患
   解决: 不能在迭代器内部使用集合自己的remove方法
   用 iterator.remove() 来替代
   remove(): 删除当前游标所在位置的元素
   不会改变游标位置
   2.迭代器的简化 -> 增强for循环 forEach
   for(每一次迭代出来的元素临时变量 : 要迭代的集合/数组) {

}
例如:
for(String s : col) {
System.out.println(s);
}
注意: forEach只能遍历元素使用, 不能迭代移除

有序二叉树: - 不允许重复

特点: 左节点 < 父节点 < 右节点
中序遍历: 左节点, 中间节点[根节点], 右节点
遍历结果: 升序

public class DemoTree {
    public static void main(String[] args) {
        SortedTree tree = new SortedTree();
        tree.add(53);
        tree.add(23);
        tree.add(10);
        tree.add(45);

        tree.travel();
    }
}

public class   SortedTree {

    private class Node {
        private int data;
        private Node left;
        private Node right;

        private Node(int data) {
            this.data = data;
        }
    }
    private Node root; // 根节点, 最开始为null
    // 给自己使用
    private void travelNode(Node node) {
        if (node.left != null) {
            travelNode(node.left);
        }
        System.out.println(node.data);
        if (node.right != null) {
            travelNode(node.right);
        }
    }

    // 给外部提供的方法
    public void travel() {
        travelNode(root);
    }
    //private void addToNode(Node node, int data) {}

    public void add(int a) {
        // 先判断a是不是第一个元素
        if (root == null) {
            root = new Node(a);
            return;
        }
        Node node = root; // 记录每一次的当前节点
        Node parentNode; // 记录每一次node的父节点
        // 不是第一个元素
        while(true) {
            parentNode = node;
            if (node.data > a) {
                // a向左边节点继续比较
                node = node.left;
                if (node == null) {
                    parentNode.left = new Node(a);
                    return;
                }
            } else if (node.data < a) {
                // a向右边节点继续比较
                node = node.right;
                if (node == null) {
                    parentNode.right = new Node(a);
                    return;
                }
            }
        }

    }
}

JavaBean规范: 实体类的书写规范
1.成员变量私有化, 提供get/set方法
2.定义无参构造方法
3.重写toString
4.重写equals 和 hashCode
5.基本数据类型建议使用包装类