day33 List接口

List实现类

java.util.ArrayList： 底层通过数组保存数据 ， 查询快，增删慢

java.util.LinkedList： 底层通过链表保存数据， 查询慢，增删快

如果对操作性能没有特殊要求，我们一般选择ArrayList即可，同时考虑具体业务

---

List方法

List<String> link = new LinkedList<>();

link.add("1");

link.get(2);

link.set(0,"一");

Collections.reverse(link);  //自动反转

for (int i = 0; i < link.size() / 2; i++) {
    String tem = link.get(i);
    link.set(i, link.get(link.size()-1-i));
    link.set(link.size()-1-i,tem);
}
System.out.println(link);  //自动反转方法二

List<Integer> subList = list.subList(3, 8); //截取集合中的子集(含头不含尾)

集合 数组 的转换

集合转换成数组

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

Collection提供了将集合转换成数组的方法

Object[] objects = c.toArray();

ArrayList重载了一个toArray方法

String[] sts = c.toArray(new String[c.size()]);

数组转换成集合

java.util.Arrays提供了一个静态方法：asList,可以将数组转换成集合

String[] arr = {"one", "two", "three", "four", "five", "six"};

List<String> list = Arrays.asList(arr);

list.set(2,"二");  //这里会直接报错
System.out.println(list); //打印集合
System.out.println(Arrays.toString(arr));  //打印数组元素
//因为数组是定长的，因此该集合的增删元素都会抛出 UnsupportedOperationException异常
//对集合的操作就是对原数组的操作
//操作数组转换的集合 会改变数组本身 
还有sublist截取的集合子集进行增删也一样会改变集合

如果必须要增删元素，需要自行创建一个新的集合
所有集合都支持一个参数为Collection的构造函数，

作用是在创建当前集合的 同时包含指定集合中的所有元素

List<String> list2 = new ArrayList<>(list);

//创建list2集合的同时包含list集合中的所有元素

集合的排序

java.utils.Collections提供了一个静态方法，short()

可以对集合进行自然排序（升序，从小到大）

Collections.sort(list);

自定义排序 Collections.sort(List list)

该方法要求集合元素必须实现接口：Comparable,否则编译不通过。

* Comparable接口是用来表示实现类是可以比较大小的，

实现类必须重写方法compareTo

* compareTo用来定义两个实例比较大小的规则。

* 例如：包装类， String类等都实现了这个接口

*

* 如果该方法不能直接使用，就不建议使用了，因为该方法对我们的代码产生了侵入性。

* 侵入性：当我们使用某个API时，其要求我们为其更改其他地方的代码，这就是侵入性。

* 侵入性不利于后期代码维护，应当尽力避免。 侵入性也大大提高了代码的耦合度，违背了

* 代码"高内聚，低耦合"的原则

自定义排序二

//COllections下的sort方法要想使用必须
        // 在元素中实现comparable接口
        //comparable接口是用来表示实现类可以比较大小
        //实现类必须重写方法
        //compareTo定义比较大下的规则

        //Collections重载了short方法
        //sort(List,Comparator)
        //需要传入一个比较器对象
//        Comparator<Point> c = new Comparator<Point>() {
//            @Override
//            public int compare(Point o1, Point o2) {
//                int m1 = o1.getX()*o1.getX() + o1.getY()*o1.getY();
//                int m2 = o2.getX()*o2.getX() + o2.getY()*o2.getY();
//                return m1-m2;
//            }
//        };
//        Collections.sort(l,c);

//        Collections.sort(l,
//            ( o1, o2) -> (o1.getX()*o1.getX() + o1.getY()*o1.getY())-(o2.getX()*o2.getX() + o2.getY()*o2.getY())
//        );

---

lambda表达式排序集合

List<String> list = new ArrayList<>();

list.add("杨玉捷");

list.add("博文");

list.add("殷桃小丸子");

list.add("西门长海");

Collections.sort(list,(s1,s2)->s1.length()-s2.length());

栈内存结构

Stack继承自Vector

* 特点： 先进后出，后进先出

* 入栈/压栈 ----数据进入栈

* 出栈/弹栈-----数据离开栈

* 栈顶元素------最后放入栈中的元素

* 栈底元素------最先放入栈中的元素

Stack s = new Stack();
s.push("a");
s.push("b");
s.push("c");
s.push("d");
s.empty();  //是否为空栈
s.pop();  //peek（）并删除
s.peek(); //获取栈顶元素
System.out.println(s);
s.search("a");  //从栈顶往下数  1开始

用双端队列表示栈

Deque d= new LinkedList();
d.add("a");
d.add("b");
d.add("c");
d.add("d");

d.pop();
d.peek();

Vector

Vector<String> v = new Vector();

System.out.println(v);
System.out.println(v.size());
System.out.println(  v.capacity());//初始容量 10 三目运算符 自动扩容
Enumeration<String> elements = v.elements();
while (elements.hasMoreElements()){
    String s = elements.nextElement();
    System.out.println(s);
}