java语法整理

数组

定义同一种类型数据的集合,数组就是一个容器,必须定义长度，自带编号，创建后会有默认值需要一个容器，但不明确数据

长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
其元素必须是相同类型，不允许出现混合类型。
数组类型可以是任何数据类型，包括基本类型和引用类型。

数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中存储的。

int[] arr = new int[5] 明确数据 int[] arr = {1,2,3,4,5}

int[] arr new int[3];
System.out.println(arr[3]) //ArrayIndexOUtOfBoundsException

arr = null;
System.out.println(arr[0]) //NullPointerException


int[] arr = {1,2,3,4,5,6,7};
User[] userUsers = {
        new User("旺财1", 1),
        new User("旺财2", 2),
        new User("旺财3", 3)
};
User[] users =new User[3];
int[] brr = new int[3];
System.out.println(brr[0]); //0
System.out.println(users[0]); //null

数组遍历

public class main {
	public static void main(String[] args) {
		int[] arr = new int[10];
		
		for (int i : arr) {
			System.out.println(i);
		}
		
		User[] userUsers = new User[3];
		for(int i=0;i<userUsers.length;i++) {
			userUsers[i] = new User("旺财"+(i+1), i+1);
		}
		for (User user : userUsers) {
			System.out.println(user.getNameString());
		}
	}
}
class User{
	private String nameString;
	private int id;
	public User(String nameString, int id) {
		super();
		this.nameString = nameString;
		this.id = id;
	}
	public String getNameString() {
		return nameString;
	}
	public void setNameString(String nameString) {
		this.nameString = nameString;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
}

数组复制

public static void main(String[] args) {
		
    int [] arr = {1,2,3,4};
    int [] brr = new int[1];
    
    //直接赋值 由于是地址传递，所以可以随意完整赋值，长度不影响赋值结果
    //brr = arr;
    
    //循环赋值 最小长度赋值
//		int arrLength = Math.min(arr.length, brr.length);
//		for(int i=0;i<arrLength;i++) {
//			brr[i] = arr[i];
//		}
    
    //使用系统方法 赋值位置和长度不能越界，否则报错
    //System.arraycopy(arr, 0, brr, 0, 4); 
    
    System.out.println(Arrays.toString(arr));
    System.out.println(Arrays.toString(brr)); 
    
}

Arrays工具类

public class TestArrays {
	public static void main(String[] args) {
		
		int [] arr = {1,2,3,4,5,6};
		int [] brr = {1,2,3,4,5,6};
		
		// Arrays.toString 返回内容的字符串形式
		System.out.println(Arrays.toString(arr)); //[1, 2, 3, 4, 5, 6]
		// Arrays.equals 相同的顺序包含相同的元素
		System.out.println(Arrays.equals(arr, brr)); //true
		System.out.println(arr.equals(brr)); //false  数组没有重写equals 用的是Object的equals
		// Arrays.copyOf 复制，和新数组长度没关系，新数组长度取决于函数的长度参数，浪费内存，用System.arrayCopy实现，存
		int [] crr = new int[2];
		crr = Arrays.copyOf(arr, 10); //效率低
		System.out.println(Arrays.toString(crr)); //[1, 2, 3, 4, 5, 6, 0, 0, 0, 0]
		//Arrays.fill 循环填充
		Arrays.fill(crr, 99);
		System.out.println(Arrays.toString(crr));//[99, 99, 99, 99, 99, 99, 99, 99, 99, 99]
		//Arrays.sort 升序
		Arrays.sort(arr);
		System.out.println(Arrays.toString(arr));
		//比较自定义类型，必须实现Comparable接口
		Person[] persons = new Person[3];
		persons[0] = new Person("小明", 19, "男");
		persons[1] = new Person("旺财", 16, "男");
		persons[2] = new Person("小强", 25, "男");
		
		Arrays.sort(persons);
		
		for (Person person : persons) {
			System.out.println(person);
		}
		
	}
}
class Person implements Comparable<Person>{
	
	private String nameString;
	private int age;
	private String sex;
	public String getNameString() {
		return nameString;
	}
	public void setNameString(String nameString) {
		this.nameString = nameString;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public Person(String nameString, int age, String sex) {
		super();
		this.nameString = nameString;
		this.age = age;
		this.sex = sex;
	}
	public Person() {
		super();
	}
	@Override
	public int compareTo(Person o) {
		return this.age - o.age;
	}
	@Override
	public String toString() {
		
		return (this.nameString + "\t" + this.age);
	}
	
}

遍历

int[] arr = {1,2,3,4,5}

for(int i=0;i<arr.length-1;i++){
    String x = "";
    if(i!=arr.length-1){
        x = ';';
    }
    System.out.print(arr[i]+x)
}

最值

//最大值 变量记录最大值
int[] arr = {1,2,3,4,5}
int max = arr[0];
for(int i=1;i<arr.length-1;i++){
    if(arr[i]>max){
        max = arr[i]
    }
}
System.out.print(max)

排序

选择排序 从小到大

//选择排序
public void selectSort(){
    for(int x=0;x<arr.length-1;x++){
        for(int y=x+1;y<arr.length;y++){
            if(arr[x]>arr[y]){
                int temp = arr[x];
                arr[x] = arr[y];
                arr[y] = temp;
            }
        }
    }
}

优化选择排序定义变量存储值和角标，利用变量来和数组元素比较，不需要换位

public void selectSortU(){
    for(int x=0;x<arr.length-1;x++){
        int num = arr[x];
        int index = x;
        for(int y=x+1;y<arr.length;y++){
            if(num>arr[y]){
                num = arr[y];
                index = y;
            }
        }
        if(index!=x){
            swap(arr,x,index);
        }
    }
}

冒泡排序

protected  int[] arrays;
int Sort(){

    // 记录执行了多少趟
    int num = 0;

    // 记录是否发生了置换， false 表示没有发生置换、 true 表示发生了置换
    boolean isChange;

    // 临时变量，用于置换
    int temp;

    // 外层循环-排序趟数-(n-1)
    for (int i=0;i<arrays.length-1;i++){

        isChange=false;

        // 内层循环-本趟中的置换次数
        for (int j=0;j<arrays.length-i-1;j++){

            // 前一位与后一位与前一位比较，如果前一位比后一位要大，那么交换
            // 并不需要与最后一位比较了，因为在第一趟排序完了，最后一位已经是最大的数了
            if(arrays[j]>arrays[j+1]){
                temp = arrays[j];
                arrays[j] = arrays[j+1];
                arrays[j+1] = temp;
                isChange=true;
            }
        }

        // 如果进到这里面了，说明发生置换了
        // 如果在某躺排序中没有发生交换位置，那么我们可以认为该数组已经排好序了
        if(isChange==false){
            break;
        }

        num++;
    }

    return num;
}

查找

二分查找

public class BinarySearch {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] arr = {5,13,19,21,37,56,64,75,80,88,92};
		int low=0;
		int hight=arr.length-1;
		int key=85;
		boolean flag=false;
		while (low<hight) {
			int mid = (low+hight)/2;
			if(key<arr[mid]) {
				hight = mid-1;
			}else if(key>arr[mid]) {
				low = mid+1;
			}else {
				System.out.println(mid);
				flag=true;
				break;
			}
		}
		if(!flag) {
			System.out.println(-low-1);
		}
	}

}

public int splitHalfSearch(int value){
    int max,min,mid;
    min = 0;
    max = arr.length-1;

    while (min<=max){
        mid = (min+max)>>1;
        if(value>arr[mid]){
            min = mid + 1;
        }else if( value < arr[mid]){
            max = mid -1;
        }else{
            return mid;
        }
    }
    return -1;
}

数组应用

进制转换

二维数组

int[][] arr = {{1,2,3},{4,5,6},{7,8,9}}'

for(int x=0;x<arr.length;x++){
    for(int y=0;y<arr[x].length;y++){
        System.out.println(arr[x][y])
    }
}

//定义二维数组的三种方式
int[][] arr = {{1,2},{3,4,5},{6}};
int[][] brr = new int[3][];
int[][] crr = new int[3][3];

//循环二维数组
for(int i=0;i<arr.length;i++) {
    for(int j=0;j<arr[i].length;j++) {
        System.out.print(arr[i][j] + "\t");
    }
    System.out.println();
}

for(int[] a : arr) {
    for(int i : a) {
        System.out.print(i+"\t");
    }
    System.out.println();
}

for(int i=0;i<arr.length;i++) {
    for(int j : arr[i]) {
        System.out.print(j+"\t");
    }
    System.out.println();
}

//数组反转
public static int[] reverse(int[] arr) {
		int temp;
		for(int i=0;i<arr.length;i++) {
			if(i==arr.length>>1) {
				break;
			}
			temp = arr[i];
			arr[i] = arr[arr.length-i-1];
			arr[arr.length-i-1] = temp;
		}
		return arr;
	}

java语法整理

数组

排序

Java后端开发相关学习笔记

Java后端开发笔记

Java 8 简明教程

对开发人员有用的定律、理论、原则和模式

从0到1实战微服务架构

浅入浅出 Android 安全