Day4 数组

双重for循环

外循环控制行，内循环控制列。

//乘法表
for(int i = ; i <= ; i++) {
     for(int j = ; j <= i ;j++) {
         System.out.print(j+"*"+i+"="+(i*j)+"\t");
     }
     System.out.println();
}

DecimalFormat

#：一个数字

0：一个数字，不够位数用0补位

DecimalFormat f = new DecimalFormat("###.##");
DecimalFormat f = new DecimalFormat("000.00000");
System.out.println(sum);
System.out.println(f.format(sum));
System.out.println(f.format(34.567));

break

用在 switch和循环中。
用在单层循环中，用来结束循环。

continue

用在循环中。
作用 结束本次循环进行下一次循环条件判断。

对于双重循环，可以自定义一个标签，break或continue 到标签处。

一维数组

Java 语言中提供的数组是用来存储固定大小的同类型元素。

声明数组

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：

int[] arr;//声明数组，告诉计算机我要存储一组整数（推荐）
或
//int arr[];

int x1,x2,x3;//声明了3个int类型的变量
int [] n1,n2,n3;//声明了3个数组
int num1 [],num2,num3;//声明了一个int类型的数组num1，两个Int类型的变量。

创建数组

arr = new int[6];//创建一个数组，计算机在内存中分配6个空间，并初始化

数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到 arr.length-1。

数组初始化

//动态初始化:我们制定长度，系统赋值。
int[] arr = new int[5];//0
//初始值
//整数：0　　小数：0.0　　布尔：false　　char:\0000　　
//String:null　　
//静态初始化:我们赋值，系统分配长度（arr2.length）
int[] arr2 = {11,22,33};

赋值数组

arr[2]=33;

栈stack

• 是作为构思算法的辅助工具，不是完全的数据存储工具。是插入和删除操作被限制在表的线性表。
• 只能从栈顶入栈，也只能从栈顶出站
• 是一种后进先出的结构

遍历数组

普通for循环

public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // 打印所有数组元素
      for (int i = 0; i < myList.length; i++) {
         System.out.println(myList[i] + " ");
      }
      // 计算所有元素的总和
      double total = 0;
      for (int i = 0; i < myList.length; i++) {
         total += myList[i];
      }
      System.out.println("Total is " + total);
      // 查找最大元素
      double max = myList[0];
      for (int i = 1; i < myList.length; i++) {
         if (myList[i] > max) max = myList[i];
      }
      System.out.println("Max is " + max);
   }
}

增强for循环

public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // 打印所有数组元素
      for (double element: myList) {
         System.out.println(element);
      }
   }
}

增强for循环的特点：

【1】简洁

【2】不能制定范围访问，只能访问全部

【3】不能反转输出，只能正序访问

【4】不能修改数组元素的值

数组排序

冒泡排序

 package day4;

 public class Demo12 {

     public static void main(String[] args) {
         // 冒泡排序
         int[] arr = {,,,,};
         int temp;
         for(int i =  ; i < arr.length-;i++) {//轮
             for(int j = ; j < arr.length--i; j++) {//次
                 if(arr[j] > arr[j+]) {
                     temp = arr[j];
                     arr[j]= arr[j + ];
                     arr[j + ] = temp;
                 }
             }
         }
         for(int n: arr) {
             System.out.println(n);
         }

     }

 }

选择排序

 package day4;

 import java.util.Arrays;

 public class Demo13 {

     public static void main(String[] args) {
         // 选择排序
         int [] arr = {,,,,};
         int temp;
         for(int i = ; i < arr.length-; i++) {//位置
             for(int j = i + ; j < arr.length; j++) {
                 if(arr[i] > arr[j]) {
                     temp = arr[i];
                     arr[i] = arr[j];
                     arr[j] = temp;
                 }
             }
         }
         for(int n:arr) {
             System.out.println(n);
         }
 //        System.out.println(Arrays.toString(arr));
     }

 }

数组查找方法

普通查找方法（效率比较低）

 public class ArrayTest {

     public static void main(String[] args) {
         // TODO Auto-generated method stub
         int[] arr = {,,,,,,,};
         int num=searchKey(arr,);
         System.out.println(num);
     }
     //查找一个元素在数组中的第一次出现的位置
     public static int searchKey(int[] arr,int key) {
         for(int i=;i<arr.length;i++) {
             if(arr[i] == key) {
                 return i;
             }
         }
         return -;//-1代表的是交表不存在的情况
     }
 }

二分查找法（效率比较高）

 public class binarySearch {
     public static void main(String[] args) {
         int[] arr = {,,,,,,,};
         int num =searchArray(arr,);
         System.out.println(num);
     }
     //二分查找。前天：数组必须是有序的。
     /*
      * 思路：
      * 1.通过角标先获取中间角标上的元素
      * 2.让该元素和要找的数据比较。
      * 3.如果要找的数大了，缩小范围，要找的范围应该是 中间的角标+1---尾角标
      *   如果要找的数效率，要找的范围   头角标---中间角标-1。
      * 4.不断如此重复，就可以找到元素对应的角标。
      * */
     public static int searchArray(int[] arr,int key) {
         int max,min,mid;
         min = ;
         max = arr.length-;
         mid = (min+max)>>;
         while(arr[mid]!=key) {
             if(key > arr[mid]) {
                 min = mid + ;
             }else{
                 max = mid - ;
             }
             //判断元素是否存在。
             if(max<min) {
                 return -;
             }
             mid = (min+max)>>;
         }
         return mid;
     }
 }

 public class ArrayTest1 {
     public static void main(String[] args) {
         int[] arr = {,,,,,,,};
         int num =binarySearch(arr,);
         System.out.println(num);
     }
     //二分查找。前天：数组必须是有序的。
     /*
      * 思路：
      * 1.通过角标先获取中间角标上的元素
      * 2.让该元素和要找的数据比较。
      * 3.如果要找的数大了，缩小范围，要找的范围应该是 中间的角标+1---尾角标
      *   如果要找的数效率，要找的范围   头角标---中间角标-1。
      * 4.不断如此重复，就可以找到元素对应的角标。
      * */
     public static int binarySearch(int[] arr,int key) {
         //定义单个变量，记录头角标，尾角标，中间角标
         int max,min,mid;
         min = ;
         max = arr.length-;
         while(min<=max) {
             mid = (min+max)>>;
             if(key > arr[mid]) {
                 min = mid + ;
             }else if(key < arr[mid]) {
                 max = mid - ;
             }else {
                 return mid;
             }
         }
         return -;
     }
 }

数组的复制

 package cn.java.study;

 import java.util.Arrays;

 public class Demo5 {
     public static void main(String[] args) {
         int[] arr1 = {,,,,};
         int[] arr2 = new int[arr1.length];
         //              源数组    源数组起始位置  目标数组  目标数组起始位置 复制长度
         System.arraycopy(arr1, , arr2, , );
         System.out.println(Arrays.toString(arr2));
     }
 }

常用API之Arrays类

 package cn.java.study;
 //工具类
 import java.util.Arrays;

 public class Demo5 {
     public static void main(String[] args) {
         //Arrays
         int[] arr = {,,,,,};
         //将数组转换成字符串
         System.out.println(Arrays.toString(arr));
         //对数组进行升序排序
         Arrays.sort(arr);
         System.out.println(Arrays.toString(arr));
         //排序数组名  排序数组元素开始位置  排序数组元素结束位置（实际上，取到终止位置减一）[起始位置，终止位置)
         Arrays.sort(arr,,);
         System.out.println(Arrays.toString(arr));
         //多核处理器下并行操作使用
         Arrays.parallelSort(arr);
         //二分查找下标，数组   查找的数字，返回的是插入点，没有的话返回的是负的插入点减一的值
         System.out.println(Arrays.binarySearch(arr, ));
         //数组比较:元素的个数和对应位置的数组元素相同
         int[] arr1 = {,,};
         int[] arr2 = {,,};
         System.out.println(Arrays.equals(arr1, arr2));
         //数组的填充,将数组中所有的元素替换为666
         Arrays.fill(arr, );
         System.out.println(Arrays.toString(arr));
         //数组的复制,返回的是一个数组,  （要复制的数组，几个元素）
         int[] arr3 = Arrays.copyOf(arr1, );
         System.out.println(Arrays.toString(arr3));
     }
 }

二维数组

格式1：

int[][] arr = new int[][];

• 定义了名称为arr的二位数组
• 二维数组中有3个一维数组
• 每一个一维数组中有2个元素
• 一维数组的名称分别为arr[0],arr[1],arr[2]
• 给第一个一维数组1角标位赋值为666的写法是：arr[0][1] = 666;

System.out.println(arr); // [[Ie6f7d2二位数组实体   e6f7d2是哈希值，[是数组，[[二位数组

格式2：

int[][] arr = new int[][];
arr[] = new int[];
arr[] = new int[];
arr[] = new int[];