Java的数组、排序和查找

public class Array01 {

	public static void main(String[] args){

		//数组的引出
		//1.定义一个数组
		//  a.double[] 表示是double类型的数组，数组名hens
		//  b.{3,5,1,3.4,2,50};表示数组的值/元素,依次表示数字组的第几个元素
		double[] hens = {3,5,1,3.4,2,50};
		//2.遍历数组得到数组的所有元素的和,使用for
		//  a.通过hens[]来访问数组的元素，下标是从0开始编号的
		//    第一个元素就是hens[0],第2个元素就是hens[1],依次类推
		//  b.通过for循环就可以循环的访问数组的元素/值
		//  c.使用一个变量taotalWeight将各个元素累积
		double totalWeight = 0;
		for(int i = 0;i < 6; i++){
			System.out.println("第"+ (i+1) +"个元素的值=" + hens[i]);
			totalWeight +=hens[i];
		}
		System.out.println("总体重=" + totalWeight + "平均体重" + (totalWeight / 6));
	}
}

import java.util.Scanner;
public class Array02{

	public static void main(String[] args) {
		//步骤
		//1.创建一个double数组，大小5
		Scanner myScanner = new Scanner(System.in);
		// (1)第一种动态分配方式
		// double score[] = new double[5];
		// (1)第二种动态分配方式，先声明数组，再new分配空间
		double score[];//声明数组
		score = new double[5];//分配内存空间，可以存放数据
		//循环输入
		for(int i = 0;i < score.length;i++){
			System.out.println("请输入第"+ (i+1) +"个成绩");
			score[i] = myScanner.nextDouble();
		}

		//遍历数组，循环输出
		for(int i = 0;i < score.length;i++){
			System.out.println("第"+ (i+1) +"个成绩是" + score[i]);
		}		
	}
}

public class ArrayDetail {

	public static void main(String[] args) {

		//1.数组是多个类型数据的组合，实现对这些数据的统一管理
		// int[] arr1 = {1,2,3,60,1.1};//double->int错误
		// int[] arr1 = {1,2,3,60,"hello"};//String -> int错误
		double[] arr2 = {1.1,2.2,3.3,60.6,100};//int->double正确
		//2.数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用
		String[] arr3 = {"北京","jack","milan"};//正确
		//3.数组创建后，如果没有赋值，有默认值int 0,short 0,byte 0,
		//long 0,float 0.0,double 0.0,char \u0000,boolean false,String null
		short[] arr4 = new short[3];//默认为3个空间块，每块存储的0
		for(int i =0;i < arr4.length;i++){
			System.out.print(arr4[i]);//000
		}
		//4.使用数组的步骤(1)声明数组并开辟空间，(2)给数组各个元素赋值(3)使用数组
		//5.数组的下标是从0开始的。
		//6.数组下标必须在指定范围内使用，否则报：下标越界异常，比如
		//int []arr==new int[5];则有效下标为0~4
		//数组的下标/索引最小是0,最大是数组长度-1
		int[] arr = new int[5];
		// System.out.println(arr[5]);//数据越界
		//7.数组属引用类型，数组型数据是对象(object)
		
	}
}

public class ArrayExercise01{

	public static void main(String[] args) {
		//思路分析
		//1.定义一个数组
		//2.'A' + 1 = 'B'，使用for循环来赋值
		//3.使用for循环输出所有元素
		char[] letter = new char[26];
		letter[0] = 'A';
		for(int i = 0;i < letter.length;i++){
			//赋值
			letter[i] = (char)(letter[0] + i);//'A'+i是int,需要强制转换
			//循环输出
			System.out.print(letter[i] + " ");
		}
	}
}

public class ArrayExercise02 {

	public static void main(String[] args){
		//思路分析
		//1.定义一个int数组
		//2.假定num[0]是max最大值，对应的索引为0
		//3.从下标1开始遍历num数组，如果max < 当前元素，说明max不是真正的最大值
		//就把max =当前元素，maxIndex=当前元素的下标。
		//4.当遍历整个数组，max就是最大值，maxIndex就是最大值的下标
		int[] num = {4,-1,9,10,23,321,-12,234,-239};
		int max = num[0];//假定num[0]是max最大值
		int maxIndex = 0;//假定maxIndex是max最大值的下标
		for(int i = 1;i < num.length;i++){ 
                        if(num[i] > max){
				max = num[i];
				maxIndex = i;
			}
		}
		System.out.println("数组最大值是" + max);
		System.out.println("数组最大值的下标是" + maxIndex);	
	}
}

public class ArrayExercise03 {

	public static void main(String[] args) {

		int[] num = {1,2,3,4,5};
		int sum = 0;
		int avg = 0;
		for(int i = 0;i < num.length;i++){
			sum += num[i];
			avg = sum / num.length;
		}
		System.out.println(sum);
		System.out.println(avg);
	}
}

public class ArrayAssign {

	public static void main(String[] args) {

		//基本数据类型赋值,赋值方式为值拷贝
		//n2的变化不会影响到n1的值
		// int n1 = 10;
		// int n2 = n1;
		// n2 = 80;
		// System.out.println(n1);//10
		// System.out.println(n2);//80
		// ====================================
		//数组在默认情况下是引用传递，赋的值是地址，
		//赋值方式为引用赋值，是一个地址,arr2的变化会影响到arr1
		int[] arr1 = {1,2,3};
		int[] arr2 = arr1;//把arr1赋值给arr2
		arr2[0] = 10;
		//看看arr1的值
		System.out.println("arr1的元素");		
		for(int i = 0;i < 3;i++){
			System.out.println(arr1[i] + " ");
		}//10 2 3
		System.out.println("arr2的元素");		
		for(int i = 0;i < 3;i++){
			System.out.println(arr2[i] + " ");
		}//10 2 3
	}
}

public class ArrayCopy {

	public static void main(String[] args) {


		int[] arr1 = {10,20,30};
		//创建一个新的数组arr2，开辟新的数据空间
		//大小为arr1.length
		int[] arr2 = new int[arr1.length];
		//遍历arr1,把arr1每个元素拷贝到arr2对应的元素位置
		for(int i = 0;i < 3;i++){
			arr2[i] = arr1[i];
		}
		//修改arr2,不会对arr1有影响
		arr2[0] = 1;
		//输出arr2
		System.out.println("====arr2的元素======");
		for(int i = 0;i < 3;i++){
			System.out.println(arr2[i]);
		}//1 20 30
		System.out.println("=====arr1的元素=====");
		//输出arr1
		for(int i = 0;i < 3;i++){
			System.out.println(arr1[i]);
		}//10 20 30
	}
}

public class ArrayReverse {

	public static void main(String[] args) {
		//方式1：通过找规律反转
		//定义数字组
		int[] arr = {11,22,33,44,55,66};
		//思路分析
		//1.把arr[0]和arr[5]进行交换{66,22,33,44,55,11}
		//2.把arr[1]和arr[4]进行交换{66,55,33,44,22,11}
		//3.把arr[2]和arr[3]进行交换{66,55,44,33,22,11}
		//4.一共交换3次=arr.length / 2
		//5.每次交换时，对应得到下标是arr[i]和arr[arr.length-i-1]
		//代码优化
		int temp = 0;
		int len = arr.length;//计算数组的长度
		for(int i = 0;i < len / 2;i++){
			temp = arr[len-i-1];
			arr[len-i-1] = arr[i];
			arr[i] = temp;
		}
		System.out.println("======翻转后数组======");		
		for(int i = 0;i < len;i++){
			System.out.println(arr[i] + "\t");
		}	

		//方式2：使用逆序赋值方式
		int[] arr1 = {11,22,33,44,55,66};
		int[]	
	}
}

public class ArrayReverse02 {

	public static void main(String[] args) {

		//方式2：使用逆序赋值方式
		int[] arr = {11,22,33,44,55,66};
		int[] arr2 = new int[arr.length];	
		int temp = 0;
		//使用逆序赋值方式
		//1.先创建一个新的数组arr2,大小为arr.length
		//2.逆序遍历arr,将每个元素拷贝到arr2的元素中(顺序拷贝
		//3.增加一个循环变量j->0~5
		for(int i = (arr.length-1),j = 0;i >= 0;i--,j++){
			arr2[j] = arr[i];
		}
		//4.for循环结束，arr2已变为逆序的数组
		//5.让arr引用指向arr2数据空间，此时arr原来的数据空间就没有变量引用，
		//会被当做垃圾销毁
		arr = arr2;
		System.out.println("=========arr的元素逆序赋值显示情况=========");
		for(int i = 0;i < arr.length;i++){
			// arr[i] = arr2[i];
			System.out.println(arr[i]);
		}
	}
}

public class ArrayAdd {

	public static void main(String[] args) {
		//思路分析
		//1.定义初始 数组int[] arr = {1,2,3};
		//2.定义一个新的数组int[] arrNew = new int[arr.length+1];
		//3.遍历arr数组，依次将arr的元素拷贝到arrNew数组
		//4.将4赋值给arrNew[arrNew.length-1]=4;把4赋值给arrNew最后一个元素
		//5.让arr指向arrNew;arr=arrNew;那么原来arr数组就被销毁
		int[] arr = {1,2,3};
		int[] arrNew = new int[arr.length+1];
		for(int i = 0;i < arr.length;i++){
			arrNew[i] = arr[i];
		}
		
		arrNew[arrNew.length-1] = 4;
		arr = arrNew;
		System.out.println("=======arr扩容后的元素情况========");
		for(int i = 0;i <arr.length;i++){
			System.out.println(arr[i]);
		}
	}
}

import java.util.Scanner;
public class ArrayAdd02 {

	public static void main(String[] args) {
		//思路分析
		//1.定义初始 数组int[] arr = {1,2,3};
		//2.定义一个新的数组int[] arrNew = new int[arr.length+1];
		//3.遍历arr数组，依次将arr的元素拷贝到arrNew数组
		//4.将4赋值给arrNew[arrNew.length-1]=4;把4赋值给arrNew最后一个元素
		//5.让arr指向arrNew;arr=arrNew;那么原来arr数组就被销毁
		//6.创建一个Scanner可以接受用户输入
		//7.因为用户什么时候退出不确定,使用do while+break来控制
		Scanner myScanner = new Scanner(System.in);
		//初始化数组
		int[] arr = {1,2,3};
		do{
			int[] arrNew = new int[arr.length+1];
			for(int i = 0;i < arr.length;i++){
				arrNew[i] = arr[i];
			}	
			System.out.println("请输入你要添加的元素?");
			int addNum = myScanner.nextInt();
			//把addNum赋值给arrNew最后一个元素
			arrNew[arrNew.length-1] = addNum;
			arr = arrNew;
			System.out.println("=======arr扩容后的元素情况========");
			for(int i = 0;i <arr.length;i++){
				System.out.print(arr[i] + "\t");
			}
			//问用户是否继续
			System.out.println("是否继续添加y/n?");
			char key = myScanner.next().charAt(0);
			if(key == 'n'){//如果输出n,就结束。
				break;
			}
		}while(true);
		System.out.println("你退出了添加");
	}
}

import java.util.Scanner;
public class ArrayReduce {

	public static void main(String[] args) {
		Scanner myScanner = new Scanner(System.in);
		int[] arr = {1,2,3,4,5};
		do{

			int[] arrNew = new int[arr.length-1];
			for(int i = 0;i < arr.length-1;i++){
				arrNew[i] = arr[i];
			}
			arr = arrNew;
			System.out.println("=====缩减后的数组是======");
			for(int i = 0;i < arr.length;i++){
				System.out.print(arr[i] + "\t");
			}
			System.out.println("\n" + "是否继续缩减?y/n");
			char key = myScanner.next().charAt(0);
			if(key == 'n'){
				break;
			}else if(arr.length == 1){
				System.out.println("===警告：不能再缩减===");
				break;
			}
		}while(true);

	}
}

public class BubbleSort {

	public static void main(String[] args) {

		//化繁为简，先死后活

		int[] arr = {24,69,80,57,13,19};
		int temp = 0;//用于辅助交换的一个变量
		//将多轮排序使用外层循环包括起来即可
		for(int j = 0;j < arr.length-1; j++){//外层循环4次
			for(int i = 0;i<arr.length-j-1;i++){// 
                //如果前面的数>后面的数，就交换
				if(arr[i] > arr[i+1]){
					temp = arr[i];
					arr[i] = arr[i+1];
					arr[i+1] = temp;

				}
			}
			System.out.println("\n=====第"+ (j + 1) +"轮=====");
			for(int i = 0;i<arr.length;i++){
				System.out.print(arr[i] + "\t");
			}			
		}
		// //第一轮
		// for(int i = 0;i<arr.length-1;i++){//4次比较 // 
                //如果前面的数>后面的数，就交换
		// 	if(arr[i] > arr[i+1]){
		// 		temp = arr[i];
		// 		arr[i] = arr[i+1];
		// 		arr[i+1] = temp;

		// 	}
		// }
		// System.out.println("=====第1轮=====");
		// for(int i = 0;i<arr.length;i++){
		// 	System.out.print(arr[i] + "\t");
		// }
		// //第二轮
		// for(int i = 0;i<arr.length-2;i++){//3次比较 // 
                //如果前面的数>后面的数，就交换
		// 	if(arr[i] > arr[i+1]){
		// 		temp = arr[i];
		// 		arr[i] = arr[i+1];
		// 		arr[i+1] = temp;

		// 	}
		// }
		// System.out.println("\n=====第2轮=====");
		// for(int i = 0;i<arr.length;i++){
		// 	System.out.print(arr[i] + "\t");
		// }
		// //第三轮
		// for(int i = 0;i<arr.length-3;i++){//2次比较
                //如果前面的数>后面的数，就交换
		// 	if(arr[i] > arr[i+1]){
		// 		temp = arr[i];
		// 		arr[i] = arr[i+1];
		// 		arr[i+1] = temp;

		// 	}
		// }
		// System.out.println("\n=====第3轮=====");
		// for(int i = 0;i<arr.length;i++){
		// 	System.out.print(arr[i] + "\t");
		// }
		// //第四轮
		// for(int i = 0;i<arr.length-4;i++){//1次比较
                //如果前面的数>后面的数，就交换
		// 	if(arr[i] > arr[i+1]){
		// 		temp = arr[i];
		// 		arr[i] = arr[i+1];
		// 		arr[i+1] = temp;

		// 	}
		// }
		// System.out.println("\n=====第4轮=====");
		// for(int i = 0;i<arr.length;i++){
		// 	System.out.print(arr[i] + "\t");
		// }
	}
}

import java.util.Scanner;
public class SeqSearch {

	public static void main(String[] args) {

		String[] arr = {"白眉鹰王","金毛狮王","紫衫龙王","青翼蝠王"};
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入名称");
		String wang = myScanner.next();
		//遍历数组，逐一比较，如果有，提示信息并退出
		//编程思维经典方法
		int index = -1;
		for(int i = 0;i < arr.length;i++){
			//比较字符串 equals
			//如果要找的名字就是当前元素
			if(wang.equals(arr[i])){
				System.out.println("数列中包含此名称,下标为" + i);
				//把i保存到index
				index = i;
				break;
			}
		}
		if(index == -1){
			System.out.println("没有此名称");
		}

	}
}

public class TwoDimensionalArray01 {

	public static void main(String[] args) {
		//什么是二维数组：
		//1.从定义形式看int[][]
		//2.原来一维数组的每个元素是一维数组，就构成二维数组。
		int[][] arr = {{0,0,0,0,0,0},{0,0,1,0,0,0},
				{0,2,0,3,0,0},{0,0,0,0,0,0}};
		//关于二维数组的关键概念
		// 1.
		System.out.println("二维数组的元素个数=" + arr.length);//4
		// 2.二维数组的每个元素是一维数组，所以如果需要得到每个一维
		// 数组的值，还需要再次遍历
		// 3.访问第(i+1)个一维数组的第j+1个值，arr[i][j];
		// 举例访问元素3，即是访问第3个一维数组的第4个值arr[2][3];
		System.out.println("第3个一维数组的第4个值=" + arr[2][3]);//3


		//输出二维图形
		for(int i = 0;i <arr.length;i++){//遍历二维数组的每个元素
			//遍历二维数组的每个元素(数组)
			//解读
			//1.arr[i]表示二维数组的第i+1个元素,比如arr[0]
			//2.arr[i].length 得到对应的每个一维数组的长度
			for(int j = 0;j < arr[i].length;j++){
				System.out.print(arr[i][j] + " ");
			}
			System.out.println();//换行
		}
	}
}

public class TwoDimensionalArray02 {

	public static void main(String[] args) {


		//int[][] arr = new int[2][3];
                int[][] arr;
                arr = new int[2][3];
		arr[1][1] = 8;
		//遍历二维数组arr
		for(int i = 0;i < arr.length;i++){
			for(int j = 0;j < arr[i].length;j++){//对每个一维数组进行遍历
				System.out.print(arr[i][j] + " ");
			}
			System.out.println();
		}
	}
}

public class TwoDimensionalArray03 {

	public static void main(String[] args) {
		//二维数组有三个一维数组，每个一维数组的元素是不一样的
		//创建二维数组，一个有3个一维数组，但是每个一维数组都没有开空间
		int[][] arr = new int[3][];
		for(int i = 0;i < arr.length;i++){//遍历arr每一个一维数组
			// 给每一个一维数组开空间 new
			// 如果没有给一维数组new，那么arr[i]就是空值null
			arr[i] = new int[i + 1];
			//遍历一维数组，并给一维数组的每个元素赋值
			for(int j = 0;j < arr[i].length;j++){
				arr[i][j] = i + 1;
			}
		}
		//遍历arr输出
		System.out.print("===arr数组元素遍历===\n");
		for(int i = 0;i < arr.length;i++){
			for(int j = 0;j < arr[i].length;j++){
				System.out.print(arr[i][j] + " ");
			}
			System.out.println();			
		}
	}
}
//结果：
//1
//2 2
//3 3 3

public class TwoDimensionalArray05 {

	public static void main(String[] args) {
		int arr[][] = {{4,6},{1,4,5,7},{-2}};
		int sum = 0;
		System.out.println("===遍历数组的结果是====");
		for(int i = 0;i < arr.length;i++){
			for(int j = 0;j < arr[i].length;j++) {
				sum +=  arr[i][j];
				System.out.print(arr[i][j] + " ");
			}
			System.out.println();
		}
		System.out.println("===遍历数组的和是====");
		System.out.println("sum=" + sum);
	}
}

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

		int[][] arr = new int[20][];
		for(int i = 0;i < arr.length;i++){//遍历arr的每个元素
			//给每个一维数组(行)开空间
			arr[i] = new int[i + 1];
			//给 每个一维数组(行)赋值
			for(int j = 0;j < arr[i].length;j++){
				//每一行的第一个元素和最后一个元素都是1
				if(j == 0 || j == arr[i].length-1){
					arr[i][j] = 1;
				}else{//中间的元素
					arr[i][j] = arr[i-1][j] +arr[i-1][j-1];
				}
			} 

		}
		//输出杨辉三角
		System.out.println("=====杨辉三角10行======");
		for(int i = 0;i < arr.length;i++){
			for(int j = 0;j < arr[i].length;j++){
				System.out.print(arr[i][j] + " ");
			}
			System.out.println();
		}

	}
}

public class Homework01 {

	public static void main(String[] args) {

		// String strs[] = {'a','b','c'};//错误，char不能赋值给String
		// String[] strs = {"a","b","c"};//正确
		// String[] strs = new  String{"a""b""c"};//错误
		String[] strs2 = new  String[]{"a","b","c"};//正确
		// String[] strs = new  String[3]{"a","b","c"};//错误

	}
}

public class Homework02 {

	public static void main(String[] args){

		String foo = "blue";
		boolean[] bar = new boolean[2];//bar[0]默认false,bar[1]默认false.
		if(bar[0]){
			foo = "green";
		}
		System.out.println(foo);//blue
	}
}

public class Homework03 {

	public static void main(String[] args){

		int num = 1;
		while(num < 10) { System.out.println(num); if(num > 5) {
				break;
			}
			num +=2;
		}//结果1 3 5 7
	}
}

import java.util.Scanner;
public class Homework04 {

	public static void main(String[] args) {
		// 已知有个升序的数组，要求插入一个元素，该数组顺序依然是
		// 升序，比如：[10,12,45,90],添加23后,数组为[10,12,23,45,90]
		// 思路
		// 本质是 数组扩容+定位
		// 1.确定添加数插入到哪个位置
		// 2.然后扩容
		//先定义原数组
		int[] arr = {10,12,45,90};
		int insertNum = 23;
		int index = -1;//index就是要插入的位置
		//遍历arr数组,如果发现insertNum <= arr[i],说明i就是要插入的位置
		//使用index保留index = i;
		//如果遍历完后，没有发现insertNum <= arr[i],说明index = arr.length
		//即添加到arr的最后
		for(int i = 0;i < arr.length;i++){
			if(insertNum <= arr[i]){
				index = i;
				break;//找到位置后，就退出
			}
		}
		//判断index的值
		if(index == -1){
			index = arr.length;
		}
		//扩容
		int[] arrNew = new int[arr.length + 1];
		//将arr的元素拷贝到arrNew,并且跳过index位置
		for(int i = 0,j = 0;i < arrNew.length;i++){
			if(i != index){//不等于情况下可以把arr的元素拷贝到arrNew
				arrNew[i] = arr[j];
				j++;
			}else{//i这个位置就是要插入的数
				arrNew[i] = insertNum;
			}
		}
		//让arr指向arrNew,原来的数组，就成为垃圾，被销毁
		arr = arrNew;		
		System.out.println("index=" + index);
		System.out.println("======插入后，arr数组的元素情况======");
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i] + "\t");
		}
	}
}

public class Homework05 {

	public static void main(String[] args) {

		int[] arr = new int[10];//默认全是0
		//(int)(Math.random() * 100) + 1 生成一个随机数1-100

		for(int i = 0;i < arr.length;i++){
			arr[i] = (int)(Math.random() * 100) + 1;
		}
		System.out.println("====arr的元素情况===");
		for(int i = 0;i < arr.length;i++){ 
                        System.out.print(arr[i] + " "); 
                } 
                System.out.println("\n====arr的元素情况(倒叙打印)==="); 
                for(int i = arr.length - 1;i >= 0;i--){
			System.out.print(arr[i] + " ");			
		}
		//平均值、最大值和最大值的下标
		double sum = arr[0];
		int maxIndex = -1;
		int max = arr[0];
		for(int i = 1;i < arr.length;i++){
			if(max < arr[i]){
				max = arr[i];
				maxIndex = i;
			}
		}
		System.out.println("\n数组的最大值是" + max);
		System.out.println("数组的最大值下标" + maxIndex);
		System.out.println("数组的和是" + sum);
		System.out.println("数组的平均值是" + sum / (arr.length));
		int number = 0;
		
		//查看数组中是否有8，按照顺序查找
		int index = -1;
		for(int i = 0;i < arr.length;i++){
			if(arr[i] == 8){
				System.out.println("===找到8了===");
				index = i;
				break;
			}
		}
		if(index == -1){
			System.out.println("===找不到8了===");
		}
	}
}

public class Homework06 {

	public static void main(String[] args) {

		char[] arr1 = {'a','z','b','c'};
		char[] arr2 = arr1;
		arr1[2] = '韩';

		for(int i = 0;i<arr2.length;i++){
			System.out.println(arr1[i] + "," + arr2[i]);
		}
	}
}

public class Homework07 {

	public static void main(String[] args) {

		//冒泡排序
		//要求从小到大排序 
		
		int[] arr = {20,-1,80,2,890,7};
		int temp = 0;//辅助交换
		for(int i = 0;i < arr.length - 1;i++){//外层循环(轮)
			for(int j = 0;j < arr.length - 1 - i;j++){//每轮的比较次数
				//从大到小排序 条件写成if(arr[j] < arr[j+1]) if(arr[j] > arr[j+1]){
					temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
		System.out.println("\n===排序后===");
		for(int i = 0;i < arr.length;i++){
			System.out.print(arr[i] + "\t");
		}
	}
}