java List基本操作

Java List中的常用操作：

1. list中添加，获取，删除元素；
2. list中是否包含某个元素；
3. list中根据索引将元素数值改变(替换)；
4. list中查看（判断）元素的索引；
5. 根据元素索引位置进行的判断；
6. 利用list中索引位置重新生成一个新的list（截取集合）；
7. 判断list是否为空；
8. 返回Iterator集合对象；
9. 将集合转换为字符串；
10. 将集合转换为数组；
11. 去重复；

1: list中添加， 获取， 删除元素.

public class TestList {
    public staic void main(String[] args) {
        List<String> list = new ArrayList<String>();
        
        //添加元素.
        list.add("Tom");
        list.add("Jam");
        list.add("Alix");
        
        //获取元素.
        String str = list.get(0);
        
        //删除元素.
        list.remove(1);
        list.remove("Alix");

        //遍历元素.
        for (String s: list) {
            Systtem.out.peintln(s);
        }
    }

}

2: list中是否包含某一个元素.

public class TestList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("Tom");
        list.add("Alix");
        
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

        //判断某一个元素是否在list中.
        String name = "Tom";
        if (list.contains(name)) {
            System.out.println("Tom in list.");
        } else {
            System.out.println("Tom not in list");
        }
    }
}

3: list中根据索引改变元素的值.

public class TestList{
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        String[] name = {"zhangsan", "Lisi", "wanger"};
        for (int i = 0; i < name.length; i++) {
            list.add(name[i]);
        }
        
        //根据索引改变list中某一个值.
        list.set(0, "Tom");

        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

4: list中根据元素的值查看索引的值.

public class TestListIndexOf{
    piblic static void main(String[] args) {
        List<Integer> num = new ArrayList<Integer>();

        num.add(1);
        num.add(2);
        num.add(3);
        num.add(2);

        //返回元素值等于2的索引.
        System.out.println(num.indexOf(2));
        //返回元素值等于2的最后的索引.
        System.out.println(num.lastIndexOf(2));
    }
}

5: 根据元素索引位置进行的判断.

public class TestList{
    public static void main(String[] args) {
        List<Integer> num = new ArrayList<Integer>();
    
        num.add(1);
        num.add(2);
        num.add(3);
        num.add(2);

        if (num.indexOf(3) == 2) {
            System.out.println("元素3在这个位置.");
        }
        if (num.lastIndexOf(2) == 3) {
            System.out.println("最后的元素2在这个位置.");
        }
    }
}

6: 利用list中索引位置重新生成一个新的list（截取集合).

public class TestList{
    public static void main(String[] args) {
        List<Integer> num = new ArrayList<Integer>();
        num.add(2);
        num.add(3);
        num.add(6);
        num.add(7);

        for (Integer i: num) {
            System.out.println(i);
        }

        //利用subList()截取， 然后给num.
        num = num.subList(1, 4);
        for (int i = 0; i < num.size(); i++) {
            System.out.println(num.get(i));
        }
    }
}

7: 判断list是否为空.

public class TestList{
    public static void main(String[] args) {
        List<String> arrayList = new ArrayList<>();

        arrayList.add("Tom");

        //判断list是否为空.
        if (arrayList.isEmpty()) {
            System.out.println("空的.");
        } else {
            System.out.println("不为空.");
        }
    }
}

8:返回iterator集合对象.

public class TestList{
    public static void main(String[] args) {
        List<String> arrayList = new ArrayList<>();
        arrayList.add("Tom");
        arrayList.add("Alix");
    
        //转化成iterator对象.
        Iterator it = arrayList.iterator();
        while(it.hasNext) {
            Object obj = it.next();
            System.out.println(obj);
        }
    }
}

9: 将集合转为string.

String str = "";
str = list.toString();
System.out.println(str);

10: 将集合转为数组.

String[] str = list.toArray();
for (String s: str) {
    System.out.println(str);
}

11: 去重复.

List<String> lst1=new ArrayList<>();
            lst1.add("aa");
            lst1.add("dd");
            lst1.add("ss");
            lst1.add("aa");
            lst1.add("ss");
 
            //第一种方法通过循环做, 根据remove方法去重复.
            for (int i = 0; i <lst1.size()-1; i++) {
                for (int j = lst1.size()-1; j >i; j--) {
                    if (lst1.get(j).equals(lst1.get(i))) {
                        lst1.remove(j);
                    }
                }
            }
            System.out.println(lst1);
             
            //第二种方法通过frequency方法.
            List<String> lst2=new ArrayList<>();
            for (String s:lst1) {
                if (Collections.frequency(lst2, s)<1) {
                    lst2.add(s);
                }
            }
            System.out.println(lst2);