zoukankan      html  css  js  c++  java
  • java

    数组长度固定不能扩展,所以现在一般采用集合

    集合分类:(所在包: java.util)

    collection   存储的是值  value

    map           存储的是键值对 key(无序不重复) - value(无序可重复)

    collection分类:

    list:有序可重复

    set:无序不重复

    list:

    ArrayList,Vector,Stack,LinkedList

    ArrayList:遍历查询速度快

    LinkedList:插入删除速度快

     ArrayList

    package List;
    
    import java.util.ArrayList;
    
    public class ArrayListTest {
        public static void main(String[] args){
    
            //ArrayList
            ArrayList arrayList1 = new ArrayList();//无参数
            ArrayList arrayList2 = new ArrayList(3);//容量
            arrayList2.add("a");
            arrayList2.add("b");
            arrayList2.add("c");
            ArrayList arrayList3 = new ArrayList(arrayList2);//collection集合,
            ArrayList arrayList4 = new ArrayList<String>(arrayList3);//可以定义arraylist内部元素的类型   -----》 泛型
    
    
            //add
            showArray(arrayList4);
            //a b c
            arrayList4.add("d");
            showArray(arrayList4);
            //a b c d
            arrayList4.add(2,"d"); // 在index = 2 的位置插入"d"
    
            //remove
            showArray(arrayList4);
            //a b d c d
            arrayList4.remove(1);
            showArray(arrayList4);
            //a d c d
            arrayList4.remove("d");  //删除第一个遇到的d
            //如果想删掉一个int类型的数字,需要remove(new Integer(1));,否则删掉的是index = 1 的对象。
    
    
    
            //modify
            showArray(arrayList4);
            //a c d
            arrayList4.set(2,"e");//inde = 2 的位置的元素 设为e (覆盖),会把旧的返回,防止删错或者用来备份
    
    
            //check
            showArray(arrayList4);
            //a c e
            System.out.println(arrayList4.get(2)); //取到inde = 2 的位置的元素
            //e
    
            //size
            System.out.println(arrayList4.size());//list的长度
            //3
    
            //list可以直接输出,重写了toString
            System.out.println(arrayList4);
            //[a, c, e]
    
    
            arrayList4.removeAll(arrayList2); // 删除arrayList4中,arrayList2[a,b,c]含有的元素
            System.out.println(arrayList4);
            //[e]
    
            arrayList4.add("a");
            arrayList4.addAll(arrayList2); // 把arrayList2[a,b,c]含有的元素添加到arrayList4中,可以重复,直接加在后面
            System.out.println(arrayList4);
            //[e, a, a, b, c]
    
            arrayList4.retainAll(arrayList2);//求交集,可重复
            System.out.println(arrayList4);
            //[a, a, b, c]
    
            //删除全部值
            //arrayList4.removeAll(arrayList4);
    
            System.out.println(arrayList4.contains("a"));//判断是否包含
            //true
            arrayList4.add("a");
            System.out.println(arrayList4.indexOf("a")); //第一个“a”出现的位置
            System.out.println(arrayList4.lastIndexOf("a"));//最后一个“a”出现的位置
            //0
            //4
    
    
            String[] sArr = new String[arrayList4.size()];
            arrayList4.toArray(sArr);  //public <T> T[] toArray(T[] a) 返回值是参数,把arrayLst的元素放入参数中传回
            for (String s:sArr) {
                System.out.print(s + " ");
            }
            System.out.println();
            //a a b c a
    
    
    
    
    
        }
    
        private static void showArray(ArrayList arrayList){
            for(Object s:arrayList){
                System.out.print(s.toString() + " ");
            }
            System.out.println();
        }
    
    }

     Vector ArrayList早期版本

    安全高(单线程访问),效率低

    默认扩容2倍,

    ArrayList是1.5倍 capacity=capacity+(capacity>>1) 

    Stack:

    栈:后进先出

    package List;
    
    import java.util.Stack;
    
    public class StackTest {
        public static void main(String[] args){
            //Stack继承了Vector,所以Vector的大部分方法都可以使用
            Stack s = new Stack(); //只有这一种构造方法
            //栈因为结构保证先进后出,所以重写和扩展的方法很少
            s.push("a"); //压入栈顶
            s.push("b");
            s.push("c");
            System.out.println(s.pop());//取出栈顶,并返回
            //c
            System.out.println(s.peek());//查看栈顶元素,不删除
            //b
            System.out.println(s);//查看所有元素
            //[a, b]
            System.out.println(s.search("a"));//查看元素位置 返回的是从栈顶开始数的第几个
            //2
            System.out.println(s.indexOf("a"));//本质存储形式还是protected Object[] elementData 逻辑上的栈
            //0
        }
    }

    Queue:

    队列:先进先出

    常用类: LinkedList

    package List;
    
    import java.util.ArrayList;
    import java.util.LinkedList;
    import java.util.Stack;
    import java.util.Vector;
    
    public class QueueTest {
        public static void main(String[] args){
            LinkedList l = new LinkedList();//继承Queue,队列先进先出
            Stack s =new Stack();
            s.push("a");
            s.push("b");
            s.push("c");
            System.out.println(s);
            //[a, b, c]
            l = new LinkedList(s); // LinkedList 构造方法可以传入collect作为参数,Stack,ArrayList都是collection的子类,所以都可以作为参数
            l.add("d");
            l.add("e");
    //        l.addFirst("a");插入第一个index = 0的位置上
    //        l.addLast("e"); 插入最后一个
            System.out.println(l);
            //[a, b, c, d, e]
    
            System.out.println(l.remove());//先进先出,所以从index = 0小的开始删,返回删除的对象,不含参数的remove是它特有的,他的父类Vector的remove必须要传递参数index或者element
            //a
            System.out.println(l);
            //[b, c, d, e]
    
            System.out.println(l.peek());//返回队列第一个值(index = 0),Stack是返回最后一个
            //b
    
            System.out.println(l.get(1));//返回index = 1,和ArrayList一样
            //c
            //总体来说LinkedList和Stack方法类似,只不过一个满足先进先出,一个满足先进后出
    
            //性能测试,100万次插入
            LinkedList linkedList = new LinkedList();
            ArrayList arrayList = new ArrayList();
    
            Long time1 = System.currentTimeMillis();
            for(int i = 0; i < 100000; i++){
                linkedList.addFirst("a");
            }
            Long time2 = System.currentTimeMillis();
            for(int i = 0; i < 100000; i++){
                arrayList.add(0,"a");
            }
            Long time3 = System.currentTimeMillis();
    
            System.out.println(time2 - time1);
            System.out.println(time3 - time2);
            //7
            //670
            //从前插入明显LinkedList更快,不过如果从末尾插入网上都说LickedList快,但是我测试多次都是ArrayList更快。。。
        }
    }
  • 相关阅读:
    LeetCode对撞指针汇总
    167. Two Sum II
    215. Kth Largest Element in an Array
    2018Action Recognition from Skeleton Data via Analogical Generalization over Qualitative Representations
    题解 Educational Codeforces Round 84 (Rated for Div. 2) (CF1327)
    题解 JZPKIL
    题解 八省联考2018 / 九省联考2018
    题解 六省联考2017
    题解 Codeforces Round #621 (Div. 1 + Div. 2) (CF1307)
    题解Codeforces Round #620 (Div. 2)
  • 原文地址:https://www.cnblogs.com/clamp7724/p/11627332.html
Copyright © 2011-2022 走看看