Introductory notes to Java 06 - String class and StringBuffer class, three collections in Java, Collection class of operation Collection, and I/O flow

Common class

String class and StringBuffer class

The String class cannot change the contents of the String object. A new String is generated after each operation

The StringBuffer class can dynamically change the string and add, delete, modify and query the original object

The difference between equals() and "= ="

equals() only determines whether the values are equal

The "= =" judgment value also determines whether the references are equal

length (): gets the number of characters of the string

Length: gets the length of the array

toCharArray(): converts a string object to a character array

Three collections of Java

They are all interfaces and need to be implemented

  1. The collection class exists in the java.util package and is a container for storing objects
  2. Collection can only hold objects. If you store int data, it will be automatically converted into an object of Integer class. (each basic type in Java has a corresponding reference type)
  3. The collection stores references to multiple objects, and the object itself is still stored in heap memory.
  4. Collection can store different types and unlimited number of data types.

1.Set: out of order and cannot be repeated

HashSet

Store collection elements according to Hash algorithm -- easy access and search

Features: the arrangement order of elements is not guaranteed. It is not repeatable. It is not thread safe. Collection elements can store null

Stored procedure: when an element is stored in the HashSet set, the HashSet will call the hashCode() method of the object to obtain the hashCode value of the object, so as to determine the position of the object in the HashSet

notes: if the equals () of two elements returns true, but their hashCode () values are inconsistent, the hashSet will store them in different locations. (this point does not conflict with non repetition and should be understood carefully)

The HashSet class implements the Set interface, which inherits from the Collection interface

package setStudy1117;

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

public class test01 {
    public static void main(String[] args) {
        Set set = new HashSet();
        //Add element add
        set.add(1);
        set.add("a");
        System.out.println(set);
        //Delete element
        set.remove(1);
        System.out.println(set);
        //Determine whether to include elements - contains
        System.out.println(set.contains(1));
        //clear all elements
        set.clear();
        System.out.println(set);
        //Traversal set————————
        set.add("a");
        set.add("b");
        set.add("c");
        set.add("d");
        System.out.println(set);
//        1. Use iterator
        Iterator iter = set.iterator();  //New iterator object
        while(iter.hasNext()){           //If there is the next one in the iterator
            System.out.println(iter.next());
        }
        System.out.println("=============================");
//        2. Iterate with enhanced for
        for (Object obj : set) {
            System.out.println(obj);
        }

        //Gets the number of elements in the collection
        System.out.println(set.size());

        //How to show the non repeatability of a Set? At present, there are four abcd elements in the Set
        set.add("a");
        System.out.println(set);//An a will not be added to the set, and the number of elements is still 4

        //null can be stored in the collection, and to calculate an element, the size must be + 1
        set.add(null);
        System.out.println(set);
        System.out.println(set.size());

    }

}
Iterator interface

It is mainly used to traverse the elements in the Collection. The iterator object is also called an iterator. The iterator is an interface and cannot create an object itself. If an iterator object is required, there must be an iterated Collection object, such as Iterator iter=set.iterator();

Necessary conditions for HashSet set to judge the equality of two objects:

  1. Both objects return true through equals()
  2. The hashCode() return values of the two objects are equal
generic paradigm

Used to limit that a collection can hold only one type of element

Format: HashSet < specify type > setstring = new HashSet < specify type > ();

public class test01 {
    public static void main(String[] args) {
        //A collection can store any type of data. Without specifying a generic type, it is equivalent to the default generic type of Object
        Set set = new HashSet();
        set.add("a");
        set.add(1);
        set.add(true);
        set.add("csdn");
        System.out.println(set);

        //Specifies that the generic type is String
        HashSet<String> setString = new HashSet<>();
        setString.add("ssdasdasd");
//        setString.add(123);———————— The compilation will report an error and the type does not match

    }
TreeSet

TreeSet class is the implementation class of SortedSet interface. TreeSet can ensure that the collection elements are in sorting state

Two sorting methods:

  • Natural sort (default), ascending
  • Custom sorting

The use of TreeSet must be guaranteed to put objects of the same type, otherwise type conversion exceptions may occur (restricted by generics)

import java.util.Set;
import java.util.TreeSet;
public class test02 {
    public static void main(String[] args) {
        Set<Integer> set= new TreeSet<Integer>();
        set.add(5);
        set.add(2);
        set.add(15);
        set.add(8);
        set.add(99);
        //Default natural sort, ascending
        System.out.println(set);  //Output [2, 5, 8, 15, 99]
		 //Use iterators to specify type traversal
        Iterator<Integer> iterator = set.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }
}

How to put custom classes into TreeSet and sort them according to the specified attributes?

  1. Custom classes need to implement the interface Comparator (java.util). When implementing this interface, we must implement the abstract method compare in it
package setStudy1117;

import java.util.Comparator;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
public class test02 {
    public static void main(String[] args) {

        Person person = new Person("Zhang San",25);
        Person person1 = new Person("Li Si",15);
        Person person2 = new Person("Wang Wu",55);
        Person person3 = new Person("lucy",35);
        Person person4 = new Person("caty",11);

        Set<Person> set= new TreeSet<Person>(new Person());
        set.add(person);
        set.add(person1);
        set.add(person2);
        set.add(person3);
        set.add(person4);

        for (Person p : set) {
            System.out.println(p.name+":  "+p.age);

        }

    }
}

class Person implements Comparator<Person> { //Save the Person object into the TreeSet type and sort it by age
    int age;
    String name;

    public Person() {
    }

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

    @Override
    public int compare(Person o1, Person o2) {  //Positive order of age
        if (o1.age>o2.age){
            return 1;
        }else if (o1.age<o2.age){
            return -1;

        }else return 0;

    }
}

Operation results

caty: 11
Li Si: 15
Zhang San: 25
lucy: 35
Wang Wu: 55

[learn about comparator.compare (), supplement]

2. List: ordered and repeatable

ArrayList class (thread unsafe)

(the Vector class is basically similar to ArrayList -- thread safe -- but it has been eliminated and will not be expanded here.)

  • The ArrayList class implements the List interface, which inherits from the Collection interface

  • Each element in the List collection has its corresponding order index. By default, the element index is set according to the order in which the elements are added

  • Some methods have been added to the List collection to manipulate the collection elements according to the index

package setStudy1117;

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

public class test03 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        list.add("b");
        list.add("sadab");
        list.add("asdasdasdb");
        list.add("ssb");
        System.out.println(list);  //Output [b, sadab, asdasdb, SSB]

        //Accesses the element at the specified location by index
        System.out.println(list.get(2));
        //Repeatability
        list.add("b");
        list.add("sadab");
        System.out.println(list);
        //Inserts an element at the specified location
        list.add(1,"f");
        System.out.println(list);

        //Inserts a collection at the specified location
        List<String> list1 = new ArrayList<>();  //New collection list1
        list1.add("123");
        list1.add("456");
        //
        list.addAll(2,list1);
        System.out.println(list);

        //Gets the index subscript of the first occurrence of the specified element in the collection. If not found, return - 1
        System.out.println(list.indexOf("aaa"));
        System.out.println(list.indexOf("123"));
        System.out.println(list.indexOf("b"));
        //Gets the index subscript of the last occurrence of the specified element in the collection. If not found, return - 1
        System.out.println(list.lastIndexOf("b"));
        
        //Removes the element at the specified location
        list.remove(7);
        System.out.println(list);

        //Changes the value of the element at the specified location
        list.set(0,"bbbbb");
        System.out.println(list);
        
        //Intercept the subsequent elements at the specified location to form a new list
        List<String> list2 = list.subList(3,5);//Excluding the right boundary, the length of the new list is equal to the end minus the start
        System.out.println(list2);

        //Get collection length
        System.out.println(list.size());
    }
}

3. Map interface: has mapping relationship

  • key and value can be data of any reference type (so there should be two generic types when creating a new object)
  • The key in the Map cannot be repeated. The unique value can be found through the specified key
  • The HashMap class is used to implement the Map interface
  • HashMap does not guarantee element order
HashMap class (thread unsafe)

(HashTable class is basically similar to HashMap -- thread safe -- but it has been eliminated and will not be expanded here.)

package setStudy1117;

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

public class Test04 {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<String, Integer>();

//      The method of adding HashMap is put ()
        map.put("Xiao Ming",1);
        map.put("Xiao Hong",551);
        map.put("White horse",51);
        map.put("Sustain",1);
        map.put("Buckle",1);
        System.out.println(map);   //The output of the map is curly braces {}, with an equal sign connecting key value pairs

        //Value according to key
        System.out.println(map.get("Xiao Hong"));
        //Delete element according to key
        map.remove("Xiao Hong");
        System.out.println(map);
        //Get length
        System.out.println(map.size());

        //Query whether there is a key or a value - contains - returns true or false
        System.out.println(map.containsKey("Xiao Ming"));
        System.out.println(map.containsValue(1));

        //Traversal of map collection:
//Method 1
//        1. First
        Set<String> keys = map.keySet();//Gets the key set of the map set
        map.values();   //Gets the value of the map collection
//        2. Then traverse the map through the key set
        for (String key : keys) {
            System.out.println("key:"+key+",value:"+map.get(key));

//Method 2 traverses through map.entrySet() -- set < entry < string, integer > > returned by this method here
            Set<Entry<String, Integer>> entries = map.entrySet();
            for (Entry<String, Integer> entry : entries) {
                System.out.println("key:"+entry.getKey()+key+",value:"+entry.getValue());;
            }
        }
    }
}

TreeMap:

You can sort the elements in the collection according to the key - natural sorting and custom sorting

Generally, map sets are used, and overly complex objects are not used as key s

package setStudy1117;

import java.util.Map;
import java.util.TreeMap;

public class Test05 {
    public static void main(String[] args) {

        //The natural sorting of TreeMap is dictionary sorting -- which can be understood as ASCII sorting
        // The number precedes the letter, and the upper case letter precedes the lower case letter
        Map<Integer, String> map = new TreeMap<>();
        map.put(1,"a");
        map.put(2,"b");
        map.put(5,"c");
        map.put(4,"a");
        System.out.println(map);//Generally, it is sorted by key. Here, the generic type of key is Integer, so it is sorted by number

        Map<String, String> map1 = new TreeMap<>();
        map1.put("Wangwanh","a");
        map1.put("shdjsa","b");
        map1.put("bjadksd","c");
        map1.put("asdjk","a");
        map1.put("15asdjk","a");
        System.out.println(map1);//Sort here according to the first ASCII ascending order of the key


    }
}

Tool class for manipulating Collections: collections class

Collections class is mainly used to process sets, lists, maps and other collections, such as sorting, addition, deletion, modification, query, inversion, and random disruption

package setStudy1117;

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

public class Test06 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("b");
        list.add("cb");
        list.add("cab");
        list.add("cb");
        list.add("a");
        list.add("1");
        System.out.println(list);
        //Invert list elements
        Collections.reverse(list);
        System.out.println(list);
        //Random disruption
        Collections.shuffle(list);
        System.out.println(list);
        //sort
        Collections.sort(list);
        System.out.println(list);//The default is in ascending dictionary order

    }
}

Sort (List, Comparator): sort the elements of the List collection according to the comparison method of the Comparator object (which needs to be rewritten)

notes:

If the element in the collection is a student, the student class must implement the Comparator interface so that the student class can override the compare method.

package setStudy1117;

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

public class Test06 {
    public static void main(String[] args) {

        Student s1 = new Student(14,"Zhang San");
        Student s2 = new Student(12,"Li Si");
        Student s3 = new Student(16,"Wang Wu");
        Student s4 = new Student(18,"Zhou Zhou");

        List<Student> stus=new ArrayList<>();
        stus.add(s1);
        stus.add(s2);
        stus.add(s3);
        stus.add(s4);
        //The original order in the output set
        for (Student student : stus) {
            System.out.println(student.name+":"+student.age);

        }System.out.println("========================");
        //Sort by Collections -- sort on the original collection -- here, the compare method is rewritten to sort in ascending order by age
        Collections.sort(stus,new Student());
        for (Student student : stus) {
            System.out.println(student.name+":"+student.age);
        }
    }
}

class Student implements Comparator<Student>{
    int age;
    String name;

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


//In ascending order of age
    @Override
    public int compare(Student o1, Student o2) {
        if(o1.age>o2.age)return 1;
        else if(o1.age<o2.age)return -1;
        else return 0;

    }
}

[learn about Comparator.compare ()]

I/O flow

Tags: Java

Posted on Wed, 17 Nov 2021 10:49:43 -0500 by Yola