第4章 数组(6课时)

常见异常

java.lang.ArrayIndexOutOfBoundsException: 5

at com.neuedu.test.Chap04.test01(Chap04.java:14)

at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)

at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)

at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)

at java.lang.reflect.Method.invoke(Unknown Source)

at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)

at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)

at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)

at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)

at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)

at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)

at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)

at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)

at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)

at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)

at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)

at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)

at org.junit.runners.ParentRunner.run(ParentRunner.java:363)

at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:86)

at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)

at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:459)

at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:678)

at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:382)

at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:192)

定义：

数组可以看成是多个相同类型数据的组合，实现对这些数据的统一管理

元素：数组里的每个值叫做一个元素

索引index：是数据在数组里存放的位置 （编号）  索引从0开始

{1,2,3,4,5}   3的索引为2

数组元素类型：可以是任何类型（四类八种基本类型+引用类型）

分类：

一维数组

 多维数组


一维数组定义

两种定义方式 

1）数组类型  数组名称[]

int a[];

2)数组类型[]  数组名称

int[] b;

给数组指定长度

int a[]=new int[4];

给数组赋值

     //第一种，用下标(索引)方式给数组赋值

      a[0]=56;

      a[1]=45;

      a[2]=18;

      a[3]=11;

      a[4]=9;

学生练习

定义一个长度为5的一维数组，给他赋值 ，并用for循环打印元素值

@Test

public void test1() {

//定义数组的两种方式

      int a[]=new int[5];

      int[] b=new int[5];

      //数组是引用类型 把地址存到栈里，把数据存到堆里

    给数组赋值

      第一种，用下标方式给数组赋值

      a[0]=56;

      a[1]=45;

      a[2]=18;

      a[3]=11;

      a[4]=9;

      //System.out.println(a[2]);

      //得到数组长度

      int len=a.length;

      //for循环打印数组的每个值

      for(int i=0;i<len;i++){

      System.out.println(a[i]);

      }

}

第二种创建同时赋值

数组类型  数组名[ ] = {元素1，元素2，…}

数组类型 数组名[ ] = new 数据类型[ ]{元素1，元素2，…}

int [] a=new int[]{1,2,3};

int [] a={3,4,5};

学生练习:

用这种方式改造刚才的程序

加强for循环(以后常用)

格式:

for(数组元素类型  循环到的变量命名:  所循环的数组名){

 语句;

}

课堂练习

编写一个长度为5的整型数组，每个元素赋值为0-10的随机整数，遍历该数组，输出每个元素。

@Test

public void test3(){

int a[]=new int[5];

for(int i=0;i<a.length;i++){

int r=new Random().nextInt(10);

a[i]=r;

}

for(int b:a){

System.out.println(b);

}

}

数组越界异常

ArrayIndexOutOfBoundsException

作业

1）线上学习多维数组的创建、初始化、内存模型

2）背冒泡排序

3）今天课堂代码写一下

数组的遍历

因为数组有下标，数组的遍历本质上是利用数组的下标，循环下标读取数据。

课堂练习：


学生练习：

1）从键盘输入班级学员成绩，计算全班学员的平均分

2）从键盘输入班级学员成绩，找出全班学员的最高分

数组复制


System.arraycopy(src, srcPos, dest, destPos, length);

//src：从哪里拷 源数组 拷贝谁

  //srcPos：从源数组中的第几个下标开始  源数组中的起始位置

  //dest:目标数组

  //destPos：目标数组中的起始位置

  //length:要复制的数组元素的个数

/**

    * 已知两个一维数组：{1,2,3,4,5}和{6,7,8}，将这两个一维数组合并成一个一维数组{1,2,3,4,5,6,7,8}。

    */

@Test

    public void exam04(){

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

    int b[]={6,7,8};

    int c[]=new int[a.length+b.length];

    //src源数组从哪里拷 源数组 拷贝谁

    //srcPos 起始位置的索引号

    //dest 目标数组

    //destPos 放到c的起始位置

    //length拷贝几个

    //把a复制到c里

    System.arraycopy(a, 0, c, 0, a.length);

    //把b复制到c里

    System.arraycopy(b, 0, c, a.length, b.length);

    for(int i=0;i<c.length;i++){

    System.out.println(c[i]);

    }

    }

数组排序

Arrays.sort(c)  全排

int c[]={4,1,8,9,6,2,1,0};

   Arrays.sort(c);

  for(int i=0;i<c.length;i++){

  System.out.println(c[i]);

  }

Arrays.sort(c, fromindex, toindex);   从哪个索引到哪个索引处进行排序，其他的不动。

 //从指定位置到终止位置进行排序

  Arrays.sort(c, 3, c.length);

  System.out.println("指定位置排序");

  for(int i=0;i<c.length;i++){

  System.out.println("---->"+c[i]);

}


课堂练习：

1）将一个字符数组的值（neusofteducation）拷贝到另一个字符数组中。（知识点：数组复制）

2 )给定一个有9个整数（1,6,2,3,9,4,5,7,8）的数组，先排序，然后输出排序后的数组的值。

冒泡排序：


//冒泡排序

@Test

public void sort(){

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

int len=a.length;

//1、n个数排序，外层的循环n-1次  i=0~n-1

for(int i=0;i<len-1;i++){//0 ~n-1

//2、里层循环j=0~n-1-i次

for(int j=0;j<len-1-i;j++){

//循环体里比对  如果a[j]>a[j+1]  两个数就交换，大的会被交换到最下面】

if(a[j]>a[j+1]){

int temp=a[j];

a[j]=a[j+1];

a[j+1]=temp;

}

}

}

System.out.println("排序后：");

for(int i=0;i<len;i++){

System.out.println(a[i]);

}

}

@Test

public void sort2(){

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

int len=a.length;

//1、n个数排序，外层的循环n-1次  i=1~n(不包括n)

for(int i=1;i<len;i++){//1 ~n

//2、里层循环j=0~n-i次

for(int j=0;j<len-i;j++){

//循环体里比对  如果a[j]>a[j+1]  两个数就交换，大的会被交换到最下面】

if(a[j]>a[j+1]){

int temp=a[j];

a[j]=a[j+1];

a[j+1]=temp;

}

}

}

System.out.println("排序后：");

for(int i=0;i<len;i++){

System.out.println(a[i]);

}

}

二维数组的创建和遍历

public static void main(String[] args) {

//创建并初始化数组

        //int[][] a=new int[][]{{1,2,3},{4,5,6}};

        int[][] a={{1,2,3},{4,5,6}};

        for(int i=0;i<a.length;i++){

        //a[0]={1,2,3} a[1]={4,5,6}

        for(int j=0;j<a[i].length;j++){

        System.out.println(a[i][j]);

        }

        }}

作业：

1）键盘输入班级学员成绩，计算全班学员每科的平均分     3科    5人

@Test

public void score() {

// 从键盘输入班级学员成绩，计算全班学员每科的平均分 (约定好是3科5人)

Scanner sc = new Scanner(System.in);

int[][] scores = new int[3][5];

while (true) {

// 逐科输入，一共输入3科

label: {

for (int i = 0; i < 3; i++) {// 几科

System.out.println("开始输入第" + i + "科学员成绩");

// 每科输入5个人的

int sum = 0;

for (int j = 0; j < 5; j++) {// 5人

System.out.println("请输入第" + j + "个学员成绩");

int score = sc.nextInt();// 第i科第j个学员成绩

if (score < 0 || score > 100) {

System.out.println("成绩不合法，重头再来");

break label;

}

scores[i][j] = score;

sum += score;

}

// 平均分=每科总成绩/总人数

double avg = sum / 5;

System.out.println("平均成绩" + avg);

}

}

// 循环打印用户输入的成绩

for (int i = 0; i < 3; i++) {

for (int j = 0; j < 5; j++) {

System.out.print(scores[i][j] + "  ");

}

System.out.println();

}

}

}

2）第4章课后习题

补充：

选择排序：



//选择排序

@Test

public void selectSort(){

//原始数据{ 3, 6, 8, 1}

//1、在一个长度为 N 的无序数组中，第一次 假设min=第一个数 遍历后面 n-1 个数找到最小的和第一个数交换。

      //第一次假设 min=3  { 3, 6, 8, 1};  {1，6，8，3}

//2、第二次从下一个数开始遍历 n-2 个数，找到最小的数和第二个数交换。

    //第二次假设 min=6  {1，6，8，3};  ==》{1，3，8，6};

//3、重复以上操作直到第 n-1 次遍历最小的数和第 n-1 个数交换，排序完成。

  //第三次假设 min=8  {1，3，8，6};  ==》{1，3，6，8};

int[] a={ 3, 6, 8,1};

int len=a.length;//4

//n个数，外层循环n-1次  0~n-1

for(int i=0;i<len-1;i++){

  //每一次，先假设当前这个数是最小值

int min=a[i];//a[0],a[1],a[2]

System.out.println("当前假设的最小值为:"+min);

//里层循环从下一个(i+1)开始到最后一个

for(int j=i+1;j<len;j++){

      if(a[j]<min){

      //交换a[j]和min

      int temp=a[j];

      a[j]=min;

      min=temp;

      }

}

System.out.println("这一软计算后的最小值为:"+min);

a[i]=min;

}

System.out.println("---------------------------");

for(int i=0;i<len;i++){

System.out.println(a[i]);

}

}

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • 2018-06-11
    mean to add the formatted="false" attribute?.[ 46% 47325/...
    ProZoom阅读 2,719评论 0赞 3
  • 第四天 数组【悟空教程】
    第四天 数组【悟空教程】 第04天 Java基础 第1章数组 1.1数组概念 软件的基本功能是处理数据，而在处理数...
    Java帮帮阅读 1,612评论 0赞 9
  • 五大常用算法二(贪心,分治)
    贪心算法 贪心算法总是作出在当前看来最好的选择。也就是说贪心算法并不从整体最优考虑，它所作出的选择只是在某种意义上...
    fredal阅读 9,266评论 3赞 52
  • Java经典问题算法(二)
    /*【程序21】 * 作者 南枫题目：求1+2!+3!+...+20!的和 1. 程序分析：此程序只是把累加变成了...
    HUC南枫阅读 452评论 0赞 0
  • 50道Java基础编程练习题
    50道经典Java编程练习题，将数学思维运用到编程中来。抱歉哈找不到文章的原贴了，有冒犯的麻烦知会声哈~ 1.指数...
    OSET我要编程阅读 7,018评论 0赞 9