数组的排序和查找

1. 数组 156

注意数组知识点

double[] hens={3,5,1,3.4,2,50};

1. double[] 表示 是 double 类型的数组， 数组名 hens

2. {3, 5, 1, 3.4, 2, 50} 表示数组的值/元素,依次表示数组的 /第几个元素

遍历数组得到数组的所有元素的和， 使用 for

解读

1. 我们可以通过 hens[下标] 来访问数组的元素

下标是从 0 开始编号的比如第一个元素就是 hens[0]

第 2 个元素就是 hens[1] , 依次类推

2. 通过 for 就可以循环的访问 数组的元素/值

数组长度

可以通过 数组名.length 得到数组的大小/长度

System.out.println("数组长度="+hens.length);

例

一个养鸡场有 6 只鸡，它们的体重分别是 3kg,5kg,1kg,3.4kg,2kg,50kg 。请问这六只鸡的总体重是多少?平 均体重是多少? 请你编一个程序。

//一个养鸡场有 6 只鸡，它们的体重分别是 3kg,5kg,1kg,3.4kg,2kg,50kg 。
//请问这六只鸡的总体重是多少?平 均体重是多少? 请你编一个程序。
public class Test18
{
  public static void main(String[] args)
  {
    //传统方法 155
    // double hen1 = 3;
    // double hen2 = 5;
    // double hen3 = 1;
    // double hen4 = 3.4;
    // double hen5 = 2;
    // double hen6 = 50;
    // double totalweight = hen1+hen2+hen3+hen4+hen5+hen6;
    // double average = totalweight/6;
    // System.out.println("总体重"+totalweight+"平均体重"+average);

    //数组  156
    //比如，我们可以用数组来解决上一个问题 => 体验 
    //定义一个数组  
    //1. double[] 表示 是 double 类型的数组， 数组名 hens 
    //2. {3, 5, 1, 3.4, 2, 50} 表示数组的值/元素,依次表示数组的 /第几个元素
    
    double[] hens={3,5,1,3.4,2,50};

    //遍历数组得到数组的所有元素的和， 使用 for
    //解读
    //1. 我们可以通过 hens[下标] 来访问数组的元素
    // 下标是从 0 开始编号的比如第一个元素就是 hens[0]
    // 第 2 个元素就是 hens[1] , 依次类推 
    //2. 通过 for 就可以循环的访问 数组的元素/值 
    //3. 使用一个变量 totalWeight 将各个元素累积
    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));
  }
}

2. 数组的使用 157

数组的动态初始化158

先声明数组

语法:数据类型 数组名[]; 也可以 数据类型[] 数组名;

int a[]; 或者 int[] a;

创建数组

语法: 数组名=new 数据类型[大小];

a=new int[10];

例：循环输入成绩

//循环输入成绩
import java.util.Scanner;
public class Test18
{
  public static void main(String[] args)
  {
    double scores[] = new double[5];//定义数组，初始化为0
    //double scores[];//先声明数组
    //scores = new double[5];//再分配空间，二者一对儿
    Scanner myScanner = new Scanner(System.in);
    for(int i=0;i<scores.length;i++)
    {
      System.out.println("请输入第"+(i+1)+"个元素的成绩");
      scores[i] =myScanner.nextDouble(); 
    }
    //遍历数组
    System.out.println("成绩如下");
    for(int i=0;i<scores.length;i++)
    {
      System.out.println("第"+(i+1)+"个成绩为"+scores[i]);
    }
  }
}

数组的静态初始化 159

3. 数组使用的注意事项160

1) 数组是多个相同类型数据的组合，实现对这些数据的统一管理

2) 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用。

3) 数组创建后，如果没有赋值，有默认值

int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String null

4) 使用数组的步骤 1. 声明数组并开辟空间 2 给数组各个元素赋值 3 使用数组

5) 数组的下标是从 0 开始的。

6) 数组下标必须在指定范围内使用，否则报：下标越界异常，比如

int [] arr=new int[5]; 则有效下标为 0-4

7) 数组属引用类型，数组型数据是对象(object)

import java.util.Scanner;
public class Test18
{
  public static void main(String[] args)
  {
    //数组是多个相同类型数据的组合，实现对这些数据的统一管理 
    //int arr[]={1,2,3,4,5,"hello"};//报错，hello时String类型
    double arr[]={1.1,2.2,3.3,60.6,100};//可以，100是int类型但是可以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];
    System.out.println("=====数组 arr4====="); 
    for(int i = 0; i < arr4.length; i++)
    { 
        System.out.println(arr4[i]); 
    }

    //6. 数组下标必须在指定范围内使用，否则报：下标越界异常，比如
      //int [] arr=new int[5]; 则有效下标为 0-4 
    //即数组的下标/索引 最小 0 最大 数组长度-1(4) 
    int [] arr = new int[5]; 
    System.out.println(arr[5]);//数组越界
  }
}

4.数组应用案例

4.1 创建一个 char 类型的 26 个元素的数组，分别 放置'A'-'Z'。使用 for 循环访问所有元素并打印出来。提示：char 类型 数据运算 'A'+2 -> 'C' 161

//创建一个 char 类型的 26 个元素的数组，分别 放置'A'-'Z'。
//使用 for 循环访问所有元素并打印出来。提示：char 类型 数据运算 'A'+2 -> 'C'
public class Test18
{
  public static void main(String[] args)
  {
    char arr[] = new char[26];
    for(int i=0;i<arr.length;i++)
    {
      arr[i] = (char)('A'+i);//因为arr是char类型，但是'A'+i是int类型，所以要强制类型转换
    }
    for(int i=0;i<26;i++)
    {
      System.out.print(arr[i]+" ");
    }
  }
}

4.2 请求出一个数组 int[]的最大值 {4,-1,9, 10,23}，并得到对应的下标。162

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

5. 数组的赋值机制 163 164

1) 基本数据类型赋值，这个值就是具体的数据，而且相互不影响。

int n1 = 2; int n2 = n1;

2) 数组在默认情况下是引用传递，赋的值是地址。

看一个案例，并分析数组赋值的内存图(重点, 难点. )。

//代码 ArrayAssign.java

int[] arr1 = {1,2,3};

int[] arr2 = arr1;

//数组的赋值机制
public class Test18
{
  public static void main(String[] args)
  {
    //基本数据类型赋值，赋值方式是值拷贝n2的值不会影响n1的值
    int n1 = 10;
    int n2 = n1;
    n2=80;
    System.out.println("n1="+n1);//10
    System.out.println("n2="+n2);//80

    //数组在默认情况下是引用传递，赋的值是地址，赋值方式是引用赋值
    int arr1[] = {1,2,3};
    int arr2[] = arr1;
    arr2[0] = 10;
    for(int i=0;i<3;i++)
    {
      System.out.println(arr1[i]);
    }
  }
}

6. 数组拷贝 165

6.1 编写代码 实现数组拷贝(内容复制)

将 int[] arr1 = {10,20,30}; 拷贝到 arr2 数组, 要求数据空间是独立的

public class Test18
{
  public static void main(String[] args)
  {
    int arr1[]={10,20,30};
    //创建一个新的数组 arr2,开辟新的数据空间 
    //大小 arr1.length;
    int[] arr2 = new int[arr1.length];
    for(int i=0;i<arr1.length;i++)
    {
      arr2[i]=arr1[i];
    }
    arr2[0]=100;

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