core java--day4(数组，二维数组，冒泡排序，插入排序，选择排序)

break:跳出当前循环
       for
       while
       do{}while();
       switch
continue:跳出本次循环，进入下一次循环（相当于打牌时，轮到你，你不出牌，过，你就跳过本次循环）
       for
       while
       do{}while();
 
数组：承载数据，承载一堆相同类型的数据
         可以存放任意数据类型
         数组的长度一经确定就不能修改(可以再new一个新的大空间的数组，将原数组拷贝过去)
         下标，从0开始，方便操作（取值，赋值）数组某个位置的数据
         最大小标，length-1
  
数组
      int[] arr = new int[5];
        arr[0] = 10;
  
一些数组的基本操作：  

package com.briup.ch4;
import java.util.*;

public class Test2{
	
	public static void main(String[] args){
		
		String[] s = new String[5];
		s[1] = "lisi";
		s[2] = "tom";
		int index = 5;
		s[index-2] = "zhaojiu";

		//按增量赋值
		int[] arr = new int[20];
		for(int i  = 0;i<arr.length;i++){
			arr[i] = i;
			}
		
		String[] s1 = {"tom","lisi","jack"};
		String mag = s1[2]+"tom";
		System.out.println(s1[2]);
		
		//数组的遍历
		for(int i = 0;i<s1.length;i++){
			String msg = s1[i];
			System.out.println(msg);
			}
		System.out.println(Arrays.toString(s1));
		
		//数组的排序：
		int[] myarr = {84,21,42,14,2,3};
		System.out.println(Arrays.toString(myarr));
		Arrays.sort(myarr);
		System.out.println(Arrays.toString(myarr));

		//数组的拷贝
		int[] target = {1,2,3,4,5};
		int[] narr = new int[target.length*2];
		System.arraycopy(target,0,narr,0,target.length);
		System.out.println(Arrays.toString(narr));
		/*
		参数1：目标数组
		参数2：从目标数组什么位置开始复制
		参数3：新数组
		参数4：老数组复制到新数组什么位置
		参数5：老数组复制多少长度到新数组里
		*/
		}

	}

 

  
  

 
  
数据类型[] 变量名 = new 数据类型[长度]
int[][] arr = new int[3][]  //把int[]当作一个数据类型，相当于在数组中的每一个小空间放一个数组
 arr[0][0] = 10;
 int da = arr[1][2];
 
 int[] arr = {1,2,3,4};
 int[][] arr = {
  {1,2,3,4}, //00 01 02 03
  {2,2,3,4}, //10 11 12 13
  {3,2,3,4}  //21 22 23
 };
 arr[0][2]; 
 
二维数组的遍历：

package com.briup.ch4;

public class Test_1{
	
	public static void main(String[] args){
		
		int[][]arr = {
			{1,2,3,4},
			{2,2,3,4},
			{3,2,3,4},
			{4,2,3}
			};

		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();
			}
		}
	}

 

 

排序：Arrays.sort(数组名);
 冒泡排序：找最大的
 

int[] arr = {12,145,36,25,63};
		for(int j = 0;j<arr.length;j++){
			for(int i = 0;i<arr.length-1-j;i++){
				if(arr[i]>arr[i+1]){
					int temp = arr[i];
					arr[i] = arr[i+1];
					arr[i+1] = temp;
				}
			}
		}
		System.out.println(Arrays.toString(arr));

 插入排序：将无序的数据一个个插入有序列表,先将第一个数看作一个排好序的序列，从第二个开始往前插，将大的往后移动，最适合的位置用index进行标记，再把要插入的数据写入
 

package com.briup.ch4;
import java.util.Arrays;
public class Test_3{
	
	
	public static void main(String[] args){
	
		int [] arr = {12,35,53,25,75,24};
		for(int j=1;j<arr.length;j++){
			
			int value = arr[j];
			int index = j;

			for(int i = j-1;i>=0;i--){
				
				if(arr[i]>value){
					
					arr[index] = arr[i];
					index = i;
					}
				}
			arr[index] = value;
			}
		System.out.println(Arrays.toString(arr));
	/*	int[] arr = {46,42,87,45,79,31};
		for(int i =1;i<arr.length;i++){
			
			for(int j =i;j>0;j--){
				
				if(arr[j]<arr[j-1]){
					
					int temp = arr[j];
					arr[j] = arr[j-1];
					arr[j-1] = temp;
					}
				}
			}
		System.out.println(Arrays.toString(arr));
*/		}
	}

 

  
选择排序(Selection sort)
 是一种简单直观的排序算法。
 它的工作原理如下。
 首先在未排序序列中找到最小元素，
 存放到排序序列的起始位置，
 然后，再从剩余未排序元素中继续寻找最小元素，
 然后放到排序序列末尾。
 以此类推，直到所有元素均排序完毕。

package com.briup.ch4;
import java.util.Arrays;
public class Test_4{
	
	public static void main(String[] args){
		
		int[] arr = {23,463,14,742,251,15};
		for(int j =0;j<arr.length;j++){
			
			int value = arr[j];
			int index = j;

			for(int i = j+1;i<arr.length;i++){
				
				if(arr[i]<value){
					
					value = arr[i];
					index = i;
					}
				}
			arr[index] = arr[j];
			arr[j] = value;
			}
		System.out.println(Arrays.toString(arr));
		}
	}

 

 

注意：编译（javac）只会检查语法错误；运行时才会找出其他一些逻辑等等错误