java回顾（map，list、list去重，排序等）

List创建，添加，遍历。

/*
8.	创建学生类。
9.	创建集合对象。
10.	创建元素对象。
11.	把元素添加到集合。
12.	遍历集合

 */

import javax.print.DocFlavor;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Student {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        //添加元素
        list.add("罗罗亚索隆");
        list.add("路飞");
        list.add("山治");
        list.add("乔巴");
        list.add("骗人布");
        list.add("罗罗亚索隆");

        //迭代器遍历
        Iterator<String> iterator = list.iterator();
        while(iterator.hasNext()){
            String s = iterator.next();
            System.out.println(s);
        }
        System.out.println("-----------");
        //普通for
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("========");
        //增强for
        for (String s : list) {
            System.out.println(s);
        }
    }
}

Map创建，添加，遍历。

public class Student1 {
    private String name;
    private int age;
    public Student1(){

    }

    public Student1(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "Student1{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}



import java.util.*;
public class text {
    public static void main(String[] args) {
        //创建map集合对象
        Map<String, Student1> map = new HashMap<>();
        //创建单列集合
        ArrayList<Student1> list = new ArrayList<>();
        //创建student1对象往里添加
        Student1 stu1 = new Student1("鸣人",18);
        Student1 stu2 = new Student1("佐助",18);
        Student1 stu3 = new Student1("春野樱",16);
        Student1 stu4 = new Student1("卡卡西",56);
        Student1 stu5 = new Student1("迈特凯",55);
        Student1 stu6 = new Student1("班",250);
        //往集合map里添加元素
        map.put("火影",stu1);
        map.put("忍者",stu2);
        map.put("忍着",stu3);
        map.put("疾风传",stu4);
        map.put("续集",stu5);
        map.put("火影忍者",stu6);


        //entryset
        Set<Map.Entry<String, Student1>> set = map.entrySet();
        for (Map.Entry<String, Student1> entry : set) {
            String key = entry.getKey();
            Student1 value = entry.getValue();
            System.out.println(key + "-->" + value);
        }
        System.out.println("=================");

        //keyset
        Set<String> keys = map.keySet();
        for (String key : keys) {
            Student1 student1 = map.get(key);
            System.out.println(key + "----" + student1);
        }
        System.out.println("**********");

        //Map<String, List<Student>> map = new HashMap<>();
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
//            拿到list集合
            List<Student1> li = (List<Student1>) map.get(key);

            //遍历list集合 拿到里面的对象
            for (Student1 student : li) {
                System.out.println(key + "--->" + student);
            }
        }
    }
}

数组创建

public class WhatEver {
    public static void main(String[] args) {
        //第一种   例:
        String[] test1 = new String[6];
        test1[0] = "大明";
        test1[1] = "二明";


        //第二种 例:
        String[] test2 = {"大明","二明","小明","...."};

        //第三种 例:
        String[] test3 = new String[]{"大明","二明","小明","...."};



    }
}

list去重

package com.javalainxi;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedHashSet;

public class Lianxi {
    public static void main(String[] args) {
        ArrayList<String> listWithDuplicateElements = new ArrayList<String>();
        listWithDuplicateElements.add("JAVA");
        listWithDuplicateElements.add("J2EE");
        listWithDuplicateElements.add("JSP");
        listWithDuplicateElements.add("SERVLETS");
        listWithDuplicateElements.add("JAVA");
        listWithDuplicateElements.add("STRUTS");
        listWithDuplicateElements.add("JSP");


        System.out.println("正常的结果：" + listWithDuplicateElements);
        HashSet<String> set = new HashSet<String>(listWithDuplicateElements);
        ArrayList<String> listWithoutDuplicateElements = new ArrayList<String>(set);
        System.out.println("去重的结果：" + listWithoutDuplicateElements);
        // 结果
        //正常的结果：[JAVA, J2EE, JSP, SERVLETS, JAVA, STRUTS, JSP]
        //去重的结果：[JAVA, SERVLETS, JSP, J2EE, STRUTS]


        //注意输出结果。你会发现，在删除重复元素之后，元素重新洗牌。
        // 不再按照插入顺序排列。如果你想在删除重复的元素之后依然保持元素的插入顺序，那么不 建议使用此方法。
        // 还有另一种方法，可以保证在删除重复的元素之后也不改变元素的插入顺序。那就是使用LinkedHashSet。
        System.out.println("====================================");
        LinkedHashSet<String> strings = new LinkedHashSet<>(listWithDuplicateElements);
        ArrayList<String> list = new ArrayList<>(strings);
        System.out.println("有顺序去重的结果：" + list);
        //结果
        //有顺序去重的结果：[JAVA, J2EE, JSP, SERVLETS, STRUTS]
    }
}