package com.test;
import static java.lang.Math.PI;
import static java.util.Arrays.*;

import java.util.ArrayList;
import java.util.List;
public class StaticDemo {
	public static void main(String[] args) {
		 /*No more Math.PI*/
		System.out.println(PI);
		List<Integer> a = new ArrayList<>();
		 /*No need to write Arrays.asList at this time*/
		a=asList(1,4,2,3);
		 /*Traditional writing in order from big to small*/
/*		a.sort(new Comparator<Integer>() {
			@Override
			public int compare(Integer o1, Integer o2) {
				return Integer.compare(o2, o1);
			}
		});*/
		 /*Lambda expression writing*/
		a.sort((o1,o2)->Integer.compare(o2, o1));
		System.out.println(a);
	}
}

Reference blog:Click to open the link

Reference blog:Click to open the link

for (data type variable name: object)
{
//The loop body is a Java statement that references a variable
}
note:
a. The variable name can be arbitrary but the data type must be the same as the data type of the traversal object.
b. The object is a container, such as an array or a collection, etc.
c. It is not possible to change the value in the object in the loop, that is, any change in the value of the object in the loop body is invalid, and the value in the object will not be changed. This is also an important difference between foreach loop and for loop. Foreach implements the traversal code of the object more concisely, and the for loop can change the value in the object.

2. Code implementation

		Set<String> set = new HashSet<String>();
		set.add("1");
		set.add("2");
		set.add("3");
		set.add("4");
		set.add("5");
		set.add(String.valueOf((int)Math.random()*10));
		for (String string : set) {
			System.out.println(string);
		}

1. The for loop is generally used to deal with relatively simple ordered collections or arrays of predictable size
2. Foreach can be used to traverse any collection or array, and the operation is simple and easy to understand. Its only downside is that it needs to understand the internal type of the collection
3. Iterator is the most powerful. It can modify or delete the elements in the collection at any time, and it is performed without knowing the type of the elements and the collection (for the reason, please refer to the third point: polymorphic difference). When you need to implement the same traversal method for different containers, iterators are the best choice

Code exercise:

package com.test;

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

public class MainDemo {
	public static void main(String[] args) {
		Set<String> set = new HashSet<String>();
		set.add("1");
		set.add("2");
		set.add("3");
		set.add("4");
		set.add("5");
		set.add(String.valueOf((int)Math.random()*10));
		 System.out.println("------------Previous state--------------");
		for (String string : set) {
			System.out.println(string);
		}
		for (Iterator<String> iterator = set.iterator(); iterator.hasNext();) {
			String next = (String)iterator.next();
			Integer of = Integer.valueOf(next);
			if(of>3){
				 iterator.remove();//Delete operation
			}
		}
		 System.out.println("-------------Deleted state--------------");
		for (String string : set) {
			System.out.println(string);
		}
	}
}

Recommended blog:Click to open the link

My article:Click to open the link

Recommended blog:Click to open the link

Code exercise:

package com.test;
enum Week{
	Mon,Stu,THU,FOu,FIR,SAT,SUN;
}
public class xx {
	Week we;
	void setWeek(Week we){
		this.we=we;
	}
	Week getWeek(){
		return we;
	}
	public static void main(String[] args) {
		xx x = new xx();
		x.setWeek(Week.Mon);
		if(x.getWeek().equals(Week.Mon)){
			System.out.println("Monday");
		}
		 //Switch supports enumeration types
		switch(x.getWeek()){
		 case Mon:System.out.println("Monday");break;
		 case Stu:System.out.println("Tuesday");break;
		 case THU:System.out.println("Wednesday");break;
		default :break;
		
		}
		 //Get enumeration object
		Week wk = Week.valueOf("Mon");
		System.out.println(wk);
		String str ="hello";
		switch(str){
		
		}
	}
}