1. Introduction of assembly framework

 

2.Collection collection common functions

 

import java.util.ArrayList;
import java.util.Collection;

public class Main {
    public static void main(String[] args) {
        Collection coll=new ArrayList<>();
        System.out.println(coll);
        coll.add(56);
        coll.add(64);
        coll.add(36);
        coll.add(78);
        coll.add(194);
        System.out.println(coll);

        boolean b = coll.remove(78);
        System.out.println(b+"\n"+coll);
        boolean b1 = coll.remove(433);
        System.out.println(b1);

        boolean b2 = coll.contains(789);
        System.out.println(b2);

        boolean empty = coll.isEmpty();
        System.out.println(empty);

        coll.clear();//void

        System.out.println(coll);


    }
}

Print results:

[]
[56, 64, 36, 78, 194]
true
[56, 64, 36, 194]
false
false
false
[]

3.Iterator iterator

 

Code implementation of 1.0 iterator

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Main {
    public static void main(String[] args) {
        Collection<String> coll=new ArrayList<>();
        coll.add("Jin Nanjun");
        coll.add("Jin shuozhen");
        coll.add("Min yunqi");
        coll.add("Zheng Haoxi");
        coll.add("Park Zhimin");
        coll.add("Jin Taiheng");
        coll.add("Tian Shiguo");
        Iterator<String> it=coll.iterator();
        /*while loop

        while(it.hasNext())
        {
            String next = it.next();
            System.out.println(next);
        }
        */
        for(;it.hasNext();)
        {
            String next = it.next();
            System.out.println(next);

        }
    }
}

　　

Print results:

Jin Nanjun
Jin shuozhen
Min yunqi
Zheng Haoxi
Park Zhimin
Jin Taiheng
Tian Zhuguo

 

 

4. Enhance for loop

 

 

 

import java.util.ArrayList;
import java.util.Collection;

public class Main {
    public static void main(String[] args) {
        demo01();//Traversal array
        demo02();//Ergodic set
    }
    private static void demo01() {
        int arc[]={54,35,24,87,90};
        for (int i:arc) {
            System.out.println(i);
        }
    }
    private static void demo02() {
        Collection<String > coll=new ArrayList<>();
       coll.add("nanami");
       coll.add("Bawei");

        for (String s:coll
             ) {
            System.out.println(s);
        }
    }


}

Print results:

54
35
24
87
90
nanami
Bawei

 

5. Generics

1.0 introduction to generics

 

2.0 benefits of generics

3.0 defining and using classes with generics

 

public class  Person<E> {
    private E name;

    public Person() {
    }

    public E getName() {
        return name;
    }

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

    public Person(E name) {
        this.name = name;
    }
}

　　

public class Main{
    public static void main(String[] args) {
        /*
          Person people=new Person();
          people.setName("Mary");
          String name = people.getName();
           System.out.println(name.length());
       */

        Person <Integer> people=new Person<>();
       people.setName(23);
        System.out.println(people.getName());


    }
}

　　

 

4.0 define and use methods with generics

public class Demo {
    public <E> void demo01(E elem){
        System.out.println(elem);
    }

}

　　

public class Main{
    public static void main(String[] args) {
    Demo de=new Demo();

    de.demo01("ashgfd");
    }
}

5.0 define and use interfaces with generics

 

 

 

public interface Interfaced<E>{
    public abstract void method(E elem);
}

　　

public interface Interfaced1<E>{
    public abstract void method1(E elem1);
}

　　

public class Demo implements Interfaced<String>{

    @Override
    public void method(String elem) {
        System.out.println(elem);
    }
}

　　

public class Demo1<I> implements Interfaced1<I> {

    @Override
    public void method1(I elem1) {
        System.out.println(elem1);
    }
}

　　

public class Main{
    public static void main(String[] args) {
        Demo demo=new Demo();
        demo.method("fhdsg");
        Demo1<String > demo1=new Demo1<>();
        demo1.method1("fsvrg");
    }
}

6.0 wildcards for generics

Use case:

import java.util.ArrayList;
import java.util.Iterator;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> list1=new ArrayList<>();
        list1.add(564);
        list1.add(85);
        list1.add(22);
        list1.add(54);
        ArrayList<String> list2=new ArrayList<>();
        list2.add("fhr");
        list2.add("mzq");
        print(list1);
        print(list2);
    }

    private static void print(ArrayList<?> list) {
        Iterator<?> it=list.iterator();
        while(it.hasNext())
        {
            Object next = it.next();
            System.out.println(next);

        }
    }
}

 

Print results:

564
85
22
54
fhr
mzq

 

6. Assemble small exercises

Happy fight against landlords

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;

public class Cardsgame {
    public static void main(String[] args) {
        //Prepare cards
        ArrayList<String> cards=new ArrayList<>();
        String[] colors={"spade","block","heart","Plum blossom"};
        String[] numbers={"2","A","K","Q","J","10","9","8","7","6","5"
        ,"4","3"};
        for (String color : colors) {
            for (String number : numbers) {
                cards.add(color+number);
            }
        }
        cards.add("king");
        cards.add("Xiao Wang");
        //shuffle the cards
        //Use the method static void shuffle (list <? > list) in collection tool class
        //Displace the specified list with the default random source
        Collections.shuffle(cards);

        //Licensing

        ArrayList<String> player1=new ArrayList<>();
        ArrayList<String> player2=new ArrayList<>();
        ArrayList<String> player3=new ArrayList<>();
        ArrayList<String> lowcards=new ArrayList<>();
        for(int i=0;i<cards.size();i++)
        {
            String s = cards.get(i);
            if(i>=51)
            {
                lowcards.add(s);
            }
            else
            {
                if(i%3==0) player1.add(s);
                else if(i%3==1) player2.add(s);
                else player3.add(s);
            }
        }
        System.out.println("Player 1"+player1);
        System.out.println("Player 2"+player2);
        System.out.println("Player 3"+player3);
        System.out.println("a hand"+lowcards);
    }
}

　

Print results:

Player 1[J, 10, 6, 4, 5, A, 2, Q, 4, 10, 6, 7, 4, K, 9, A, A]
Player 2 [spades 10, diamonds 7, hearts 6, clubs K, spades 7, clubs 8, diamonds 4, clubs 9, hearts 8, kings, spades 2, clubs J, hearts 5, spades 3, spades Q, hearts 2, clubs 6]
Player 3 [box 8, box 2, Xiao Wang, spade 8, spade 9, box K, plum Q, box 9, box 3, spade 5, spade 10, spade K, spade A, box Q, plum 3, plum 7, box 5]
Bottom card [hearts 3, spades J, diamonds J]

 

7.List interface

 

 

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Main{
    public static void main(String[] args) {
        //Get List set polymorphism
        List<String> list=new ArrayList<>();

        //add()
        list.add("bts");
        list.add("dsfh");
        list.add("shdgf");
        list.add("sunshine");
        list.add(1,"Army");
        System.out.println(list);

        //remove
        String remove = list.remove(2);
        System.out.println(remove);
        System.out.println(list);

        //set
        list.set(2,"love");
        System.out.println(list);

        //get
        //ergodic
        /*iterator */

        Iterator<String> iterator = list.iterator();
        while(iterator.hasNext()  )
        {
            String next = iterator.next();
            System.out.println(next);
        }

        /*for*/
        for(int i=0;i<list.size();i++)
        {
            String s = list.get(i);
            System.out.println(s);

        }
        
        /*foreach*/

        for (String s : list) {
            System.out.println(s);
        }
    }
}

 

 

Print results

[bts, Army, dsfh, shdgf, sunshine]
dsfh
[bts, Army, shdgf, sunshine]
[bts, Army, love, sunshine]
bts
Army
love
sunshine
bts
Army
love
sunshine
bts
Army
love
sunshine

 

 

8.LinkedList set

 

import java.util.LinkedList;

public class Main{
    public static void main(String[] args) {
        show1();//add
        show2();//get
        show3();//remove
    }

    private static void show3() {
        LinkedList<String> linked = new LinkedList<>();
        linked.add("you");
        linked.add("are");
        linked.add("mine");
        String s = linked.removeFirst();
        System.out.println("The first element that pops up is"+s);
        linked.removeLast();
        linked.pop();//removefirst()
        System.out.println(linked);
        boolean empty = linked.isEmpty();
        System.out.println(empty);
    }

    private static void show2() {
        LinkedList<String > linked = new LinkedList<>();
        linked.add("a");
        linked.add("b");
        linked.add("c");
        System.out.println("The first element of the collection is:"+linked.getFirst());
        System.out.println("The tail elements of the collection are:"+linked.getLast());
    }

    private static void show1() {
        LinkedList<String> linked = new LinkedList<>();
        linked.add("love");
        //linked.addFirst("I");//push
        linked.push("I");
        linked.addLast("you");//add
        System.out.println(linked);
    }
}

　　

Print results:

[I, love, you]
The first element of the collection is: a
The tail element of the set is: c
The first element that pops up is you
[]
true

9.Set interface

 

 

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class Main{
    public static void main(String[] args) {
        Set<Integer> set=new HashSet<>();
        set.add(1);
        set.add(4);
        set.add(3);
        set.add(1);
        System.out.println(set);
        //Ergodic set
        /*iterator */
        Iterator<Integer> iterator = set.iterator();
        while(iterator.hasNext())
        {
            Integer next = iterator.next();
            System.out.println(next);
        }
        System.out.println("=============");

        /*foreach*/
        for (Integer integer : set) {
            System.out.println(integer);
        }
    }
}

　

Print results:

[1, 3, 4]
1
3
4
=============
1
3
4

 

The structure of the data stored in the HashSet collection

The Hashset collection stores custom elements

import java.util.Objects;

public class Person{
    private String name;
    private int 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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

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

    public Person() {
    }

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

　　

import java.util.HashSet;

public class Main{
    public static void main(String[] args) {
        Person p1=new Person("V",25);
        Person p2=new Person("V",25);
        Person p3=new Person("V",18);
        HashSet<Person> people = new HashSet<>();
        people.add(p1);
        people.add(p2);
        people.add(p3);
        System.out.println(people);//Overridden toString method
        /*
        //[Person{name='V', age=18}, Person{name='V', age=25}, Person{name='V', age=25}]
        boolean equals = p1.equals(p2);
        System.out.println(equals);//false
        System.out.println("p1:"+p1.hashCode()+" p2:"+p2.hashCode());
        //So the equals comparison is false and the hash values are different, so the elements are different
        */
        //Rewrite Hashcode equals
        boolean equals = p1.equals(p2);
        System.out.println(equals);//true
        System.out.println("p1:"+p1.hashCode()+" p2:"+p2.hashCode());//3652
        //[Person{name='V', age=25}, Person{name='V', age=18}]

    }
}

 

LinkedHashSet set set

 

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

public class Main{
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();
        set.add("add");
        set.add("tre");
        set.add("bde");
        set.add("add");
        System.out.println(set);//[add, bde, tre] out of order and not repeated

        LinkedHashSet<String> linked = new LinkedHashSet<>();
        linked.add("add");
        linked.add("tre");
        linked.add("bde");
        linked.add("add");
        System.out.println(linked);//[add, tre, bde] no repetition

    }
}

 

10. Hash value

 

import java.util.Objects;

public class Main{
    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person();
        int h1, h2;
        h1 = p1.hashCode();
        h2 = p2.hashCode();
        System.out.println(h1);//1355531311
        System.out.println(p1);//actual Person@50cbc42f
        System.out.println(h2);//1967205423
        System.out.println(p2);//Person@75412c2f

        //The hash value of the String class overrides toString
        String s1=new String("abc");
        String s2=new String("abc");
        System.out.println(s1.hashCode());//96354
        System.out.println(s2.hashCode());//96354

        System.out.println("Heavy ground".hashCode());//1179395
        System.out.println("conversation".hashCode());//1179395

    }
}

 

11.Collections collection tool class

1.0 methods of collections

import java.util.ArrayList;
import java.util.Collections;

public class Main{
    public static void main(String[] args) {
        ArrayList<Integer> array = new ArrayList<>();
        Collections.addAll(array,1,2,3,4,5,6,7,8,9);
        System.out.println(array);

        Collections.shuffle(array);
        System.out.println(array);
    }
}

 

Print results:

[1, 2, 3, 4, 5, 6, 7, 8, 9]
[5, 9, 3, 7, 8, 2, 4, 6, 1]

　

2.0 Collections.sort()

1)public static<T> void sort(list<T> list)

 

 

import java.util.Objects;

public class Person implements Comparable<Person>{
    private String name;
    private int 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 "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public Person() {
    }

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

    @Override
    public int compareTo(Person o) {
        //Sort by age
        return this.getAge()-o.getAge();
       }
}

　　

import java.util.ArrayList;
import java.util.Collections;

public class Main{
    public static void main(String[] args) {
        ArrayList<Integer> array = new ArrayList<>();
        Collections.addAll(array,45,23,9,56,10);
        System.out.println(array);
        Collections.sort(array);
        System.out.println(array);

        //Custom class
        ArrayList<Person> list = new ArrayList<>();
        Person p1=new Person("V",25);
        Person p2=new Person("JK",23);
        Person p3=new Person("Jimin",25);
        Collections.addAll(list,p1,p2,p3);
       //Override compareTo
        Collections.sort(list);
        System.out.println(list);
    }
}

 

 

Print results:

[45, 23, 9, 56, 10]
[9, 10, 23, 45, 56]
[Person{name='JK', age=23}, Person{name='V', age=25}, Person{name='Jimin', age=25}]

2)public static <T> void sort(List<T> list,Comparator<? super T>)

 

 

public class Students {
    private String name;
    private int age;

    @Override
    public String toString() {
        return "Students{" +
                "name='" + name + '\'' +
                ", 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;
    }

    public Students() {
    }

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

　　

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Main{
    public static void main(String[] args) {
        ArrayList<Students> students = new ArrayList<>();
        Students s1=new Students("Lisa",23);
        Students s2=new Students("Jisoo",25);
        Students s3=new Students("Rose",23);
        Students s4=new Students("Jennie",24);
        Collections.addAll(students,s1,s2,s3,s4);
        Collections.sort(students, new Comparator<Students>() {
            @Override//Anonymous Inner Class 
            public int compare(Students o1, Students o2) {
                return o1.getAge()-o2.getAge()  ;//Ascending by age
            }
        });
        System.out.println(students);

        //Multiple conditional sorting
        //Age is the same as the first letter
        Collections.sort(students, new Comparator<Students>() {
            @Override
            public int compare(Students o1, Students o2) {
                int result=o1.getAge()-o2.getAge();
                if(result==0)
                {
                    result=o2.getName().charAt(0)-o1.getName().charAt(0);
                }
                return result;
            }
        });
           System.out.println(students);

    }
}

　

Print results:

[Students{name='Lisa', age=23}, Students{name='Rose', age=23}, Students{name='Jennie', age=24}, Students{name='Jisoo', age=25}]
[Students{name='Rose', age=23}, Students{name='Lisa', age=23}, Students{name='Jennie', age=24}, Students{name='Jisoo', age=25}]

 

12.Map set

1.0 overview of map collection and common subclasses

 

2.0 common methods in Map interface

 

import java.util.HashMap;
import java.util.Map;

public class Main{
    public static void main(String[] args) {
        Map<String,Integer> map=new HashMap<>();
        //put method
        Integer jimin = map.put("Jimin", 25);
        System.out.println(jimin);//null
        Integer jimin1 = map.put("Jimin", 26);
        System.out.println(jimin1);//25
        map.put("V",25);
        map.put("JK",23);
        System.out.println(map);
        //{JK=18, V=25, Jimin=26}

        //remove()
        Integer jimin2 = map.remove("Jimin");
        System.out.println(jimin2);//26
        System.out.println(map);
        //{JK=18, V=25}

        //get()
        Integer jk = map.get("JK");
        System.out.println("JK Age:"+jk);
        //JK's age: 23

        //containsKey()
        boolean b = map.containsKey("Jhope");
        System.out.println(b);//false
    }
}

 

3.0 Map set traversal key value finding

 

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Main{
    public static void main(String[] args) {
        Map<String,Integer> map=new HashMap<>();
        map.put("RM",27);
        map.put("Jin",28);
        map.put("JK",23);

        Set<String> set = map.keySet();
        Iterator<String> iterator = set.iterator();

        //iterator 
        while(iterator.hasNext())
        {
            String key = iterator.next();
            Integer value = map.get(key);
            System.out.println(key+" "+value);
        }

        System.out.println("==============");
        //foreach

        for (String s : set) {
            System.out.println(s+" "+map.get(s));
        }
    }
}

　　

Print results:

JK 23
RM 27
Jin 28
==============
JK 23
RM 27
Jin 28

4.0 Map set traversal key value pairs

 

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Main{
    public static void main(String[] args) {
        Map<String,String> map=new HashMap<>();
        map.put("Jin Taiheng","V");
        map.put("Park Zhimin","Jimin");
        map.put("Tanaka","JK");

        Set<Map.Entry<String, String>> entries = map.entrySet();
        Iterator<Map.Entry<String, String>> it = entries.iterator();
        while(it.hasNext()){
            Map.Entry<String, String> next = it.next();
            String key = next.getKey();
            String value = next.getValue();
            System.out.println(key+" "+value);
        }

        System.out.println("=====================");
        for (Map.Entry<String, String> entry : entries) {
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+" "+value);
        }


    }
}

 

Print results:

Jimin Park
Jin Taiheng V
Tian Suguo JK
=====================
Jimin Park
Jin Taiheng V
Tian Guiguo JK

5.HashMap storage custom type

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Main{
    public static void main(String[] args) {
        //< String, person > key value does not repeat String overrides Hashcode and equals
        HashMap<String,Person> map=new HashMap<>();
        map.put("bts",new Person("Jin Taiheng",25));
        map.put("bts",new Person("Tian Shiguo",23));
        map.put("blackpink",new Person("Lisa",23));
        Set<String> set= map.keySet();
        for (String s : set) {
            Person person = map.get(s);
            System.out.println(s+" "+person);
        }

        System.out.println("==================");

        //< Person, string > key value does not repeat Person overrides Hashcode and equals

        HashMap<Person, String> map1 = new HashMap<>();
        map1.put(new Person("Jimin",25),"BTS");
        map1.put(new Person("Jimin",25),"bts");
        map1.put(new Person("Jin",28),"BTS");
        Set<Map.Entry<Person, String>> set1 = map1.entrySet();
        for (Map.Entry<Person, String> entry : set1) {
            Person key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+" "+value);


        }

    }
}

　　

Print results:

bts Person{name = 'Tian Shiguo', age=23}
blackpink Person{name='Lisa', age=23}
==================
Person{name='Jimin', age=25} bts
Person{name='Jin', age=28} BTS

 

6.LinkedHashmap set

Inherited HashMap set hash table + linked list (record storage order)

import java.util.HashMap;
import java.util.LinkedHashMap;

public class Main{
    public static void main(String[] args) {
        HashMap<String, Integer> hashmap = new HashMap<>();
        hashmap.put("V",25);
        hashmap.put("RM",26);
        hashmap.put("Suga",27);
        hashmap.put("JK",23);
        System.out.println(hashmap);
        //{JK=23, V=25, RM=26, Suga=27}
        System.out.println("==============================");
        LinkedHashMap<String,Integer> map=new LinkedHashMap<>();
        map.put("V",25);
        map.put("RM",26);
        map.put("Suga",27);
        map.put("JK",23);
        System.out.println(map);
        //{V=25, RM=26, Suga=27, JK=23}
    }
}

　　

7.Hashtable set

 

8. Small application of map set

Count the number of characters in a string

import java.util.HashMap;
import java.util.Scanner;
import java.util.Set;

public class Main{
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        System.out.println("Please enter a string:");
        String str=input.next();
        HashMap<Character, Integer> map = new HashMap<>();
        for (char c : str.toCharArray()) {
            if(map.containsKey(c)){
                //existence
                Integer value = map.get(c);
                value++;
                map.put(c,value);
            }
            else
            {
                map.put(c,1);
            }
        }
        Set<Character> set = map.keySet();
        for (Character key : set) {
            System.out.println("Characters:"+key+" The number is:"+map.get(key));
        }
    }
}

 

Print results:

Please enter a string:

sdhgfgdsfiwe
Characters: s: 2
Characters: d: 2
Characters: e: 1
Characters: f: 2
Characters: g: 2
Characters: w: 1
Characters: h: 1
Characters: i: 1

 

 

 

13.JDK9 optimization of set addition

import java.util.List;
import java.util.Map;
import java.util.Set;

public class Main{
    public static void main(String[] args) {
        List<String> list = List.of("a", "b", "c", "d");
        System.out.println(list);
       // list.add("e");//UnsupportedOperationException

        //Set<String> set =  Set.of ("e", "F", "g", "H", "e"); / / duplicate element
        //IllegalArgumentException
        //System.out.println(set);


        Map<String, Integer> map = Map.of("V", 25, "JK", 23, "Jimin", 25);

        System.out.println(map);
        //Key cannot repeat IllegalArgumentException: duplicate key: V
        //Map<String, Integer> map1 = Map.of("V", 25, "JK", 23 , "Jimin", 25,"V", 25);

    }
}

　　

 

Print results:

[a, b, c, d]
{V=25, JK=23, Jimin=25}