Java数组练习题(带答案)培训讲学

J a v a数组练习题(带

答案)

1)数组的元素通过下标来访问，数组Array的长度为 Array.length 。

2)数组复制时，"="将一个数组的引用传递给另一个数组。

3)JVM将数组存储在栈 (堆或栈)中。

4)数组的二分查找法运用的前提条件是数组已经排序。

5)Java中数组的下标的数据类型是整型。

6)数组最小的下标是 0 。

7)arraycopy()的最后一个参数指明复制元素的个数。

8)向方法传递数组参数时，传递的是数组的引用。

9)数组初始化包括数组的申明，创建和初始化。

10)数组下标访问超出索引范围时抛出数组越界异常

11)浮点型数组的默认值是 0.0f 。

12)数组创建后其大小不能改变。

二选择题

1.下面错误的初始化语句是_ABD__

A. char str[]="hello";

B. char str[100]="hello";

C. char str[]={'h','e','l','l','o'};

D. char str[]={'hello'};

2.定义了一维int型数组a[10]后，下面错误的引用是_B__

3. A. a[0]=1; B. a[10]=2; C. a[0]=5*2; D. a[1]=a[2]*a[0];

4.下面的二维数组初始化语句中，正确的是____

5. A. float b[2][2]={0.1,0.2,0.3,0.4}; B. int a[][]={{1,2},{3,4}};

6. C. int a[2][]= {{1,2},{3,4}}; D. float a[2][2]={0};

7.引用数组元素时，数组下标可以是_D___

8. A. 整型常量 B. 整型变量 C. 整型表达式 D. 以上均

可

9.定义了int型二维数组a[6][7]后，数组元素a[3][4]前的数组元素个数为____

A. 24

B. 25

C. 18

D. 17

10.下列初始化字符数组的语句中，正确的是__B__

11.A. char str[5]="hello"; B. char str[]={'h','e','l','l','o','\0'};

12.C. char str[5]={"hi"}; D. char str[100]="";

13.数组在Java中储存在 C 中

14.A. 栈 B. 队列 C. 堆D. 链表

15.下面程序的运行结果是____

main() {

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

System.out.printf("%d", a[1][1]);

}

A. 3

B. 4

C. 5

D. 6

16.下面程序的运行结果是_C___

int x=30;

int[] numbers=new int[x];

x=60;

System.out.println(numbers.length);

}

A. 60

B. 20

C. 30

D. 50

18.下面程序的运行结果是__BDF__

19.main() {

20.char s1[]="ABCDEF".toCharArray();

21.int i=0;

22.while(s1[i++]!='\0')

System.out.println(s1[i++]);

}

A. ABCDEF

B. BDF

C. ABCDE

D. BCDE

23.下面不是创建数组的正确语句C

24. A.float f[][]=new float[6][6]; B.float f[]=new float[6];

25. C.float f[][]=new float[][6]; D.float [][]f=new float[6][];

26.下面不是数组复制方法的是(C)

A. 用循环语句逐个复制数组

B. 用方法arraycopy

C. 用"="进行复制

D. 用clone方法

27.数组a的第三个元素表示为D

A. a(3)

B. a[3]

C.a(2)

D. a[2]

28.当访问无效的数组下标时，会发生B

A. 中止程序

B. 抛出异常

C. 系统崩溃

D. 直接跳过

29.使用arraycopy()方法将数组a复制到b正确的是A

A. arraycopy(a,0,b,0,a.length)

B. arraycopy(a,0,b,0,b.length)

C.. arraycopy(b,0,a,0,a.length)

D. arraycopy(a,1,b,1,a.length)

30.关于数组默认值，错误的是 B

A. char--'"u0000'

B. Boolean--true

C. float--0.0f

D. int-- 0

31.关于数组作为方法的参数时，向方法传递的是 A

A. 数组的引用

B. 数组的栈地址

C. 数组自身

D. 数组的元素

32.关于数组复制，下列说法错误的是AC

A. "="可以实现数组复制

B. 运用循环语句进行数组复制必须两个数组长度相同

C. arraycopy()方法没有给目标数组分配内存空间

D. 数组复制是数组引用的传递

33.下列语句会造成数组new int[10]越界是D

A. a[0] += 9;

B. a[9]=10;

C. —a[9]

D. for(int i=0;i<=10;i++) a[i]++;

34.在JDK环境下编译JAVA源程序使用的命令是(B )

A.java

B.javac

C.jvm

D.tomcat

D. 子类不能使用父类的构造方法

35.main方法是java Application 程序执行的入口点。关于main方法放入方法

以下合法的是( )

A. public static void main();

B. public static void main(String[]args)

C. public static int main(String[] arg)

D. public void main(String arg[])

36.执行完代码"int[] x=new int[25];"后以下( A )说明正确的

A. x[24]为0

B. x[24]未定义

C. x[25]为0

D. x[0]为

空

37.关于数组排序方法，错误的是 C

A. 选择排序

B. 插入排序

C. 二分排序

D. 用arrays.sort( )排序

38.关于char类型的数组，说法正确的是 D

A. 其数组的默认值是'A'

B. 可以仅通过数组名来访问数组

C. 数组不能转换为字符串

D. 可以存储整型数值

39.对于数组a[10]，下列表示错误的是B

A. a[0]

B. a(0)

C. a[9]

D. a[1]

40.下列数组声明，下列表示错误的是

A. int[] a

B. int a[]

C. int[][] a

D. int[]a[]

三、是非题

1.下标用于指出数组中某个元素位置的数字。( )

2.把数组中元素按某种顺序排列的过程叫做查找。( )

3.确定数组中是否含有某个关键字的过程叫做排序。( )

4.一个数组可以存放许多不同类型的数值。( )

5.数组的下标通常是float型。( )

6.数组的某个元素被传递给一个方法并被该方法修改，当被调用方法执行完毕时，这个元素中含有修改过的数值。( )

7.数组可以声明为任何数据类型。( )

8.数组由具有一名字和相同类型的一组连续内存单元构成。( )

9.在数组声明中可以用等号及一个逗号分隔的初始值表初始化数组元素，该数组大小只能由用户来决定。( )

10.将一个数组传递给一个方法，必须加在数组名后加方括号。( )

11.Java语言中的数组元素下标总是从0开始，下标可以是整数或整型表达式。( )

12.下面这条语句正确吗？( )

double[] myList;

myList = {1.9, 2.9, 3.5, 4.6};

14. 数组中有length()这个方法，如array.length()表示数组array中元素的个数( )

15.下面这条语句正确吗?( )

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

16.数组声明后其大小固定。( )

17.设有整型数组的定义：int A.[]=new int[8]; ，则a.length的值为7。( )

18. 数组一旦创建，其大小不能再改变。( )

19.用任何方式创建数组时，都必须指定数组的长度。( )

20.声明数组时，要指定数组长度，以便为数组分配内存。( )

四、简答题

1. 如何声明和创建一个一维数组？

2. 如何访问数组的元素？

3.数组下标的类型是什么？最小的下标是什么？一维数组a的第三个元素如何

表示？

4.数组越界访问会发生什么错误？怎样避免该错误？

5.给方法传递数组参数与传递基本数据类型变量的值有何不同？

6.复制数组有哪些方法？

8.声明数组变量会为数组分配内存空间吗？为什么？

五、程序题

1.有一个整数数组，其中存放着序列1，3，5，7，9，11，13，15，17，19。

请将该序列倒序存放并输出。

1)public class Test {

2)public static void main(String[] args) {

3)int a[] = {1,3,5,7,9,11,13,15,17,19};

4)int t;

5)System.out.println("数组的初始状态为:");

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

7)System.out.print(" " + a[i]);

8)System.out.println();

9)

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

11)t = a[i];

12)a[i] = a[a.length-i-1];

13)a[a.length-i-1]=t;

14)}

15)

16)System.out.println("数组逆序存放后的状态为:");

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

18)System.out.print(" " + a[i]);

20)}

2.编写一个程序，提示用户输入学生数量姓名和他们的成绩，并按照成绩的降序来打印学生的姓名。

1)public class exercise16 {

2) public static void main(String[] args) {

3) String numberString =

4) JOptionPane.showInputDialog("Enter the number of students");

5) int numberOfStudents = Integer.parseInt(numberString);

6)

7) String[] names = new String[numberOfStudents];

8) double[] scores = new double[numberOfStudents];

9)

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

11) names[i] = JOptionPane.showInputDialog("Enter a student name");

12) scores[i] = Double.parseDouble(

13) JOptionPane.showInputDialog("Enter a student score"));

14) }

15)

16) for (int i = scores.length - 1; i >= 1; i--) {

17) double currentMax = scores[0];

18) int currentMaxIndex = 0;

19)

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

21) if (currentMax < scores[j]) {

22) currentMax = scores[j];

23) currentMaxIndex = j;

24) }

25) }

26)

27) if (currentMaxIndex != i) {

28) scores[currentMaxIndex] = scores[i];

29) scores[i] = currentMax;

30) String temp = names[currentMaxIndex];

31) names[currentMaxIndex] = names[i];

32) names[i] = temp;

33) }

34) }

35)

36) for (int i = scores.length - 1; i >= 0; i--) {

37) System.out.println(names[i] + "\t" + scores[i]);

38) }

39) }

3.编写一个程序，使它能够读入10个整数，并且存储其中互不相同的数，最后将这10个数输出。

1)import javax.swing.JOptionPane;

2)

3)public class exercise5 {

4)private static int j = 0;

5)

6)public static void main(String[] args) {

7)int[] arrayInt = new int[10];

8)int i = 0;

9)

10)do {

11)String numberString = JOptionPane

12).showInputDialog("Enter a number: ");

13)

14)int number = Integer.parseInt(numberString);

15)

16)if (isNotHave(arrayInt, number)) {

17)arrayInt[i] = number;

18)i++;

19)j++;

20)}

21)else

22){

23)do {

24)numberString = JOptionPane

25).showInputDialog("This number

is exit,enter a another number: ");

26)number = Integer.parseInt(numberString);

27)} while (!isNotHave(arrayInt, number));

28)

29)arrayInt[i] = number;

30)i++;

31)j++;

32)}

33)} while (i < arrayInt.length);

34)

35)String output = "";

36)for (int k : arrayInt) {

37)output += k + " ";

38)}

39)

40)JOptionPane.showMessageDialog(null, "The elements of arrayInt is "

41)+ output, "output arrayInt",

https://www.doczj.com/doc/b215294507.html,RMATION_MESSAGE);

42)}

43)

44)public static boolean isNotHave(int[] arrayInt, int n) {

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

46)if (arrayInt[i] == n)

47)return false;

48)}

49)return true;

50)}

51)}

4.先对数组{1，3，9，5，6，7，1，5，4，8}进行排序，然后二分查找法找出数组中的元素8，标出其排序后其下标的位置。

1)public class Test {

2)public static void main(String[] args) {

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

4)java.util.Arrays.sort(numbers);

5)

6)System.out.println("排序后的数组为:");

7)for (int i=0; i

8)System.out.print(" " + numbers[i]);

9)System.out.println();

10)

11)int n = binarySearch(numbers, 8);

12)System.out.println("数字8的位置为:" + n);

13)

14)}

15)

16)public static int binarySearch(int[] list, int key) {

17)int low = 0;

18)int high = list.length - 1;

19)int mid = 0;

20)

21)while (high > low) { mid = (mid == (low + high) / 2) ?

22) (mid + 1) : ((low + high) / 2);

23)if (key < list[mid])

24)high = mid - 1;

25)else if (key == list[mid])

26)return mid;

27)else

28)low = mid - 1;

29)}

30)return -low - 1;

31)}

32)}

5.编写一个程序，读入数目确定的考试分数，并且判断有多少个分数高于或等于平均分，有多少个分数低于平均分。输入一个负数标志输入结束，假设最高分为100。

1)import javax.swing.JOptionPane;

2)

3)public class Test {

4) public static void main(String[] args) {

5) double[] scores = new double[100];

6) double sum = 0;

7) int count = 0;

8)

9) do {

10) String scoreString =

11) JOptionPane.showInputDialog(null, "Enter a new score");

12) scores[count] = Double.parseDouble(scoreString);

13) sum += scores[count];

14) } while (scores[count++] >= 0);

15)

16) double average = (sum - scores[count]) / (count - 1);

17)

18) int numOfAbove = 0;

19) int numOfBelow = 0;

20) for (int i = 0; i < count - 1; i++)

21) if (scores[i] >= average)

22) numOfAbove++;

23) else

24) numOfBelow++;

25)

26) System.out.println("Average is " + average);

27) System.out.println("Number of scores above or equal to the average "

28) + numOfAbove);

29) System.out.println("Number of scores below the average "

30) + numOfBelow);

31)

32) System.exit(0);

33) }

34)}

6.编写一个程序，生成0-9之间的100个随机整数并且显示每一个数的个数。

1)public class exercise7 {

2)public static void main(String[] args) {

3)int[] numbers = new int[100];

4)int[] counts = new int[10];

5)

6)int k;

7)for (int i = 0; i < 100; i++)

8){

9)numbers[i] = (int)(Math.random() * 10);

10)counts[numbers[i]]++;

11)}

12)

13)System.out.println("the 100 numbers is :");

14)for(int i = 1; i <= numbers.length; i++)

15){

16)if (i % 10 != 0)

17) System.out.print(numbers[i-1] + " ");

18)else

19)System.out.println(numbers[i-1]);

20)}

21)

22)System.out.println("the counts of each number is :");

23)for(int i = 1; i <= counts.length; i++)

24)System.out.print(counts[i-1] + " ");

25)}

26)}

7. 求平均值和方差。利用 mean(int []numbers)求平均值，利用 deviation(int []numbers)求标准差。

1)import java.util.Scanner;

2)public class MeanDeviation {

3)public static void main(String[] args) {

4)Scanner in = new Scanner(System.in);

5)

6)System.out.print("输入数组的长度:");

7)int n = in.nextInt();

8)

9)System.out.print("输入数组元素:");

10)int[] array = new int[n];

11)for (int i = 0; i < array.length; i++)

12){

13)array[i] = in.nextInt();

14)}

15)

16)System.out.print("The mean is: " + mean(array) + "\n"

17)+ "The deviation is: " + deviation(array));

18)}

19)

20)public static double mean(int []numbers)

21){

22)double sum = 0.0;

23)for(int i = 0; i < numbers.length; i++)

24){

25)sum += numbers[i];

26)}

27)return sum / numbers.length;

28)}

29)

30)public static double deviation(int []numbers)

31){

32)double powSum = 0.0;

33)for(int i = 0; i < numbers.length; i++)

34){

35)powSum += Math.pow(numbers[i] - mean(numbers),2);

36)}

37)

38)return Math.sqrt(powSum / (numbers.length - 1));

39)}

40)}

8.编写一个程序，求出整数数组中最小元素的下标。如果这样的元素个数大于1，则返回下标最小的数的下标。

1)public class MinIndex {

2) public static void main(String[] args) {

3) int[] list = {1, 2, 4, 5, 10, 100, 2, -22};

4)

5) System.out.println("The min is " + minIndex(list));

6) }

7)

8) public static int minIndex(int[] list) {

9) int min = list[0];

10) int minIndex = 0;

11)

12) for (int i = 1; i < list.length; i++)

13) if (min > list[i]) {

14) min = list[i];

15) minIndex = i;

16) }

17)

18) return minIndex;

19) }

Java数组与Java基础类实验报告

西安邮电大学 （计算机学院） 课内实验报告 实验名称：数组与Java基础类 专业名称：计算机科学与技术 班级：计科1405班 学生姓名：高宏伟 学号：04141152 指导教师：刘霞林 实验日期：2016.10.27

一、实验目的 掌握Java中的数组定义、引用，掌握String类和StringBuffer类的使用。 二、实验要求 1．编写一个使用Java 数组的的程序。 2．编写一个使用String类的程序。 3．编写一个使用StringBuffer类的程序。 三、实验内容 (一) 使用数组求Fibonacci数列前10项之和 1.编写程序。 public class Fibonacci { public static void main(String args[]){ int i=0,j=1,s=0; for(int n=1;n<=5;n++){ s+=(i+j); i = (int)(i+j); j = (int)(i+j); } System.out.print("前10项之和是："+s); } } 2.编译并运行程序。 （二）练习String类的常用方法 ?实验要求： 编写一个Java应用程序，判断两个字符串是否相同，判断字符串的前缀、后缀是否和某个字符串相同，按字典顺序比较两个字符串的大小关系，检索字符串，创 建字符串，将数字型字符串转换为数字，将字符串存放到数组中，用字符数组创建 字符串。。 ?程序模板： StringExample.java class StringExample { public static void main(String args[]) { String s1=new String("you are a student"),s2=new String("how are you"); if(【代码1】) // 使用equals方法判断s1与s2是否相同 { System.out.println("s1与s2相同"); }

JAVA类与对象及数组习题及答案

JAV A类和对象及数组习题 一、选择题 （1）下列构造方法的调用方式中，正确的是（D ）--原因：在通过new实例化一个类对象时系统会自动调用该类相应的构造方法。 A．按照一般方法调用B．由用户直接调用 C．只能通过new自动调用D．被系统调用 （2）在Java中，能实现多重继承效果的方式是（C ）--原因：一个类可以同时实现多个接口。Java接口反映了对象较高层次的抽象，还弥补了Java只支持单继承的不足，可用它来完成多继承的一些功能。 A．内部类B．适配器C．接口D．同步 （3）int型public成员变量MAX_LENGTH，该值保持为常数100，则定义这个变量的语句是( D )—原因：java中定义常量用关键字final来定义。 A．public int MAX_LENGTH=100 B．final int MAX_LENGTH=100 C．public const int MAX_LENGTH=100 D．public final int MAX_LENGTH=100 （4）下列叙述中，正确的是( A )—原因：Java严格区分大小写，所以变量number 与Number不相同；Java 中的注释方式除了“//”行注释之外还有段注释“/*-------*/”和文档注释/**-------*/。Java源文件中的public类只能有一个。 A. 声明变量时必须指定一个类型 B. Java认为变量number与Number相同 C. Java中唯一的注释方式是"//" D. 源文件中public类可以有0或多个 （5）下列叙述中，错误的是( D )—原因：子类继承父类，并且可以有自己的成员变量和成员方法。所以可以认为子类是父类的扩展。

Java类 类型的数组创建与使用方法

Java类数组的使用方法一 注意一定要把类数组的每一个元素都赋值，否则就报错，既对类数组对象的一空声明，如果并没有实例化，会报空指针异常：NullPointerException 1.创建类类型的数组方法一： 创建一个Person类，在main方法中创建p1,p2,p3,p4 几个Person 类的实例化对象。然后再使用如下代码创建类类型的数组p。Product [] p=new Product[]{p1,p2,p3,p4}; public class Test { public static void main(String[] args) { Product p1=new Product(); https://www.doczj.com/doc/b215294507.html,="豆浆机"; Product p2=new Product(); https://www.doczj.com/doc/b215294507.html,="电视机"; Product p3=new Product(); Product p4=new Product(); Product [] p=new Product[]{p1,p2,p3,p4};//创建类类型的数组方法一 for(int i=0;i

} } class Product{ int Num; String name; } 2.创建类类型的数组方法二： public class Test { public static void main(String[] args) { Product p1=new Product(); Product p2=new Product(); Product p3=new Product(); Product p4=new Product(); Product [] p={p1,p2,p3};//创建类类型的数组方法二for(int i=0;i

Java_数组练习题目

一填空题 1)数组的元素通过数组下标来访问，数组Array的长度为元素的个数 （Array.length）。 2)Java中数组的下标的数据类型是整形。 3)不用下标变量就可以访问数组的方法是数组名。 4)数组最小的下标是0 。 5)arraycopy()的最后一个参数指明复制元素的个数。 6)向方法传递数组参数时，传递的是数组的引用。 7)数组初始化包括数组的声明，创建，初始化。 8)数组下标访问超出索引范围时抛出数组越界异常 9)浮点型数组的默认值是0.0f 。 10)对象型数组的默认值是null 。 二选择题 1.下面错误的初始化语句是_A B D__ A. char str[]="hello"; B. char str[100]="hello"; C. char str[]={'h','e','l','l','o'}; D. char str[]={'hello'}; 2.定义了一维int型数组a[10]后，下面错误的引用是_B_ A. a[0]=1; B. a[10]=2; C. a[0]=5*2; D. a[1]=a[2]*a[0]; 3.下面的二维数组初始化语句中，正确的是__B__ A. float b[2][2]={0.1,0.2,0.3,0.4}; B. int a[][]={{1,2},{3,4}}; C. int a[2][]= {{1,2},{3,4}}; D. float a[2][2]={0}; 4.引用数组元素时，数组下标可以是__D__ A. 整型常量 B. 整型变量 C. 整型表达式 D. 以上均可 5.定义了int型二维数组a[6][7]后，数组元素a[3][4]前的数组元素个数为__C__ A. 24 B. 25 C. 18 D. 17 6.下列初始化字符数组的语句中，正确的是_B___ A. char str[5]="hello"; B. char str[]={'h','e','l','l','o','\0'}; C. char str[5]={"hi"}; D. char str[100]=""; 7.数组在Java中储存在 C 中 A. 栈 B. 队列 C. 堆 D. 链表

java数组的概念和作用

1 数组的概念 和其他语言一样，Java也提供数组支持，数组是属于引用类型，即数组是一个 对象。 强调数组的类型是引用类型。 数组的基本概念及作用 数组是相同数据类型元素的集合 数组本身是引用数据类型，即对象。但是数组可以存储基本数据类型，也可以存储引用数据类型。 数组的举例 int [] a = new int []{1,2,3,4,5}; String [] s = new String []{"小熊","小小熊","小小小熊"}; Employee [] e=new Employee[10];（Employee是自定义类） 2 数组的声明 数组的声明的两种方式： 数据类型 [] 数组名字例如：int [] a; 数据类型数组的名字 [] 例如： int a []; 注意： 在Java语言中两种声明方法没有任何区别，但是建议大家用第一种，避免混淆a的数据类型。 数组在声明后还只是一个空指针，不能使用，要想使用必须创建。 数组创建的三种方式：

?//声明数组的同时，根据指定的长度分配内存，但数组中元素值都为默认的初始化值 char[] chAry = new char[10]; ?//声明数组并分配内存，同时将其初始化 ?int[] ary1 = new int[]{1, 2, 3, 4, 5}; ?//与前一种方式相同，仅仅只是语法相对简略 ?int[] ary2 = {1, 2, 3, 4, 5}; 从另一个角度，数组创建可以分为动态和静态两种 动态创建数组（没有为元素赋值，可以结合for循环进行赋值） char[] chAry = new char[10]; 静态创建数组，在创建的时候，即为每个元素赋初值 int[] ary1 = new int[]{1, 2, 3, 4, 5}; 数组的长度 数组的长度：length属性 int [] b1 = new int []{1,2,3,4,5,6,7}; System.out.println(b1.length); 注意：数组的长度是属性，String的长度是length（）； 创建数组的时候必须指定数组的长度，而且一经定义则不允许改变。 数组的长度虽然是7，但是在内存中实际给8个位置，另外一个存储7. 数组之间赋值 在C语言中，不可以将数组直接赋值给另一个数组；

Java数组练习题(带答案)

一填空题 1)数组的元素通过下标来访问，数组Array的长度为Array.length 。 2)数组复制时，"="将一个数组的引用传递给另一个数组。 3)JVM将数组存储在栈(堆或栈)中。 4)数组的二分查找法运用的前提条件是数组已经排序。 5)Java中数组的下标的数据类型是整型。 6)数组最小的下标是0 。 7)arraycopy()的最后一个参数指明复制元素的个数。 8)向方法传递数组参数时，传递的是数组的引用。 9)数组初始化包括数组的申明，创建和初始化。 10)数组下标访问超出索引范围时抛出数组越界异常 11)浮点型数组的默认值是0.0f 。 12)数组创建后其大小不能改变。 二选择题 1.下面错误的初始化语句是_ABD__ A. char str[]="hello"; B. char str[100]="hello"; C. char str[]={'h','e','l','l','o'}; D. char str[]={'hello'}; 2.定义了一维int型数组a[10]后，下面错误的引用是_B__ A. a[0]=1; B. a[10]=2; C. a[0]=5*2; D. a[1]=a[2]*a[0]; 3.下面的二维数组初始化语句中，正确的是____ A. float b[2][2]={0.1,0.2,0.3,0.4}; B. int a[][]={{1,2},{3,4}}; C. int a[2][]= {{1,2},{3,4}}; D. float a[2][2]={0}; 4.引用数组元素时，数组下标可以是_D___ A. 整型常量 B. 整型变量 C. 整型表达式 D. 以上均可 5.定义了int型二维数组a[6][7]后，数组元素a[3][4]前的数组元素个数为____ A. 24 B. 25 C. 18 D. 17 6.下列初始化字符数组的语句中，正确的是__B__ A. char str[5]="hello"; B. char str[]={'h','e','l','l','o','\0'}; C. char str[5]={"hi"}; D. char str[100]=""; 7.数组在Java中储存在 C 中 A. 栈 B. 队列 C. 堆 D. 链表 8.下面程序的运行结果是____ main() { int a[][]={{1,2,3},{4,5,6}}; System.out.printf("%d", a[1][1]); } A. 3 B. 4 C. 5 D. 6 9.下面程序的运行结果是_C___ main() {

JAVA数组与List之间相互转换的方法详解

数组与List之间相互转换的方法详解 1.List转换成为数组。（这里的List是实体是ArrayList) 调用ArrayList的toArray方法。 toArray public T[] toArray(T[] a)返回一个按照正确的顺序包含此列表中所有元素的数组；返回数组的运行时类型就是指定数组的运行时类型。如果列表能放入指定的数组，则返回放入此列表元素的数组。否则，将根据指定数组的运行时类型和此列表的大小分配一个新的数组。 如果指定的数组能容纳列表并有剩余空间（即数组的元素比列表的多），那么会将数组中紧跟在集合末尾的元素设置为null。这对确定列表的长度很有用，但只在调用方知道列表中不包含任何null 元素时才有用。 指定者： 接口Collection 中的toArray 指定者： 接口List 中的toArray 覆盖： 类AbstractCollection 中的toArray 参数： a - 要存储列表元素的数组，如果它足够大的话；否则，它是一个为存储列表元素而分配的、具有相同运行时类型的新数组。 返回： 包含列表元素的数组。 抛出： ArrayStoreException - 如果a 的运行时类型不是此列表中每个元素的运行时类型的超类型。 具体用法： 复制代码代码如下: List list = new ArrayList(); list.add("1");

list.add("2"); finalint size = list.size(); String[] arr = (String[])list.toArray(new String[size]); 2.数组转换成为List 调用Arrays的asList方法. JDK 1.4对java.util.Arrays.asList的定义，函数参数是Object[]。所以，在1.4中asList()并不支持基本类型的数组作参数。 JDK 1.5中，java.util.Arrays.asList的定义，函数参数是Varargs, 采用了泛型实现。同时由于autoboxing 的支持，使得可以支持对象数组以及基本类型数组。 不过在使用时，当传入基本数据类型的数组时，会出现小问题，会把传入的数组整个当作返回的List中的第一个元素，例如： 复制代码代码如下: public static void main(String[] args){ int[] a1 = new int[]{1,2,3}; String[] a2 = new String[]{"a","b","c"}; System.out.println(Arrays.asList(a1)); System.out.println(Arrays.asList(a2)); } 1.打印结果如下： 复制代码代码如下: 1 2 [[I@dc8569] [a, b, c] 下面说说Arrays.asList()的返回值： JDK文档是这么说的： public static ListasList(T... a) 返回一个受指定数组支持的固定大小的列表。（对返回列表的更改会“直接写”到数组。）此方法同Collection.toArray() 一起，充当了基于数组的API 与基于collection 的API 之间的桥梁。返回的列表是可序列化的，并且实现了RandomAccess。此方法还提供了一个创建固定长度的列表的便捷方法，该列 复制代码代码如下:

Java数组与方法

若想要存放一连串相同数据类型的数据，使用数组是个相当好用的选择。此外，如果某个程序片段经常反复出现，那么将它定义成一个方法可以有效地简化程序代码。本章主要是介绍数组的基本用法与方法的应用，学完本章，将会对数组与方法的使用有更深一层的认识。 数组是由一组相同类型的变量所组成的数据类型，它属于引用类型。它们以一个共同的名称表示，数组中的每个元素则以下标来访问。数组依照存放元素的复杂程度分为一维数组、二维和多维数组，先来看看一维数组。 3.1 一维数组 一维数组可以存放上千万个数据，并且这些数据的类型是完全相同的。可以将它简单的理解为是相同数据类型的数据的集合。 3.1.1 一维数组的声明与内存的分配 要使用Java的数组，必须经过两个步骤： （1）声明数组 （2）给数组分配内存 这两个步骤的语法如下： 数据类型数组名[ ]; 或数据类型[ ] 数组名; // 声明一维数组 数组名= new 数据类型[个数]; // 给数组分配内存 数组的声明格式里，“数据类型”是声明数组每个元素的数据类型，常见的类型有整型、浮点型与字符型等，也可以是引用类型。“数组名”是用来统一这组相同数据类型的元素的名称，其命名规则和变量的相同，建议使用有意义的名称为数组命名。数组声明后，接下来便是要配置数组所需的内存，其中“个数”是告诉编译器，所声明的数组要存放多少个元素，而“new”则是命令编译器根据括号里的个数，在内存中开辟一块内存供该数组使用。 需要注意的是，在Java中声明数组的时候，不能在[]中指定其长度。比如：int score[3]; // 错误 下面是关于一维数组的声明并分配内存给该数组的一个范例： int score[]; // 声明整型数组score score = new int[3]; // 为整型数组score分配内存空间，其元素个数为3 在上例中的第一行，当声明一个整型数组score时，score可视为数组类型的变量，此时这个变量并没有包含任何内容，编译器仅会分配一块内存给它，用来保存指向数组实体的地址，如图3-1所示。 图3-1 声明整型数组 声明之后，接着要做内存分配的操作，也就是上例中第二行语句。这一行会开辟3个可供保存整数的内存空间，并把此内存空间的参考地址赋给score变量。其内存分配的流程如图3-2所示。

java中数组的学习完整版一

1.知识点 一维数组：定义、初始化、使用（相关的算法，常用系统类的使用） 多维数组：定义、初始化、使用 增强for循环，break、continue控制语句的学习 2.讲解 什么是数组？ 例子 //要求把一个班的一门课的成绩，加起来求平均值； import java.util.*; class Average{ public static void main(String[] args){ Scanner sc = new Scanner(System.in); float avg=0; float sum=0; int count=1; while(count<=3){ sum=sum+sc.nextFloat(); count++; } avg=sum/(count-1); System.out.println("平均值是:"+avg); System.out.println("程序结束"); } } //新要求：我要在输出平均值的同时，也要将这门课的最高分，最低分，同时也要能看到这门的成绩 数组概念：一组能够存储相同数据类型值的变量的集合。 在java中我们本着一切是对象的原则，我们把数组在java中看成是对象，数组对象。数组是最基本的引用型数据类型。 一维数组的知识点 定义方法： 1、三步法 A、int[] arr;用来申明数组的引用，在栈中为arr开辟内存； B、arr = new int[5];这是为数组arr在堆中为数组元素开辟6个存储单元； C、把数组在堆中的起始位置给了arr这个引用变量 *一般我们的程序在运行时，我们为局部变量在栈中开辟内存，而为对象(对象属性)在堆中开辟内存。为对象方法在方法区开辟内存空间。为类的属性，在静态区开辟内存空间。 具体的内存图：

JAVA数组基础学习知识-情况总结与简单规范标准示范

只为成功找方法，不为失败找借口！ java基础学习总结——数组 一．数组的基本概念 ?数组可以看成是多个相同类型数据组合，对这些数据的统一管理。 ?数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。 ?数组的元素可以是任何数据类型，包括基本类型和引用类型。 ?C和C++中的数组都可以分配在栈上面，而JAVA中的数组是只能分配在堆上面的，因为JAVA中的数组是引用类型。 二．一维数组 一维数组的声明方式有2种： ?格式一：数组元素类型数组名[ ]; 即type var[ ]; ?格式二：数组元素类型[ ] 数组名; 即type[ ] var; ?格式二声明数组的方法与C#上声明一维数组的方法一样。 例如：int a1[ ]; int[ ] a2; double b[ ]; person[ ] p1; String s1[ ]; 注意：JAVA语言中声明数组时不能指定其长度(数组中的元素个数) 如：int a[5]; 这样声明一维数组是非法的。 三．数组的模型 ?一维数组：一维数组就是一行，一行小格。 ?二维数组：二维数组就是一行加一列组成的一个平面分成的小格，有行有列。 ?三维数组：三维数组就是一个立方体。 ?人类对最多认识到三维空间。 四．数组对象的创建 JAVA中使用关键字new创建数组对象。 格式为：数组名= new数组元素的类型[数组元素的个数]

例如： 五．元素为引用数据类型的数组 注意：元素为引用数据类型的数组中的每一个元素都需要实例化。例如： class Date{ int year; int moth; int day; Date(int y; int m, int d){ year=y ; month=m ; day=d ; } }

JAVA数组的排序方法实例

冒泡排序法 1.public class SortArray_01 { 2. public static void main(String args[]) { 3. int[] array = { 14, 5, 86, 4, 12, 3, 21, 13, 11, 2, 55 }; // 创建一个初始化的一维数组array 4. System.out.println("未排序的数组:"); 5. for (int i = 0; i < array.length; i++) { // 遍历array数组中的元素 6. System.out.print(" " + array[i]); // 输出数组元素 7. if ((i + 1) % 5 == 0) // 每5个元素一行 8. System.out.println(); 9. } 10. int mid; // 定义一个中间变量， 起到临时存储数据的作用 11. for (int i = 0; i < array.length; i++) { // 执行冒 泡排序法 12. for (int j = i; j < array.length; j++) { 13. if (array[j] < array[i]) { 14. mid = array[i]; 15. array[i] = array[j]; 16. array[j] = mid; 17. } 18. } 19. } 20. System.out.println("\n使用冒泡法排序后的数组:"); 21. for (int i = 0; i < array.length; i++) { // 遍历排好序的array数组中的元素 22. System.out.print(" " + array[i]); // 输出数组元素 23. if ((i + 1) % 5 == 0) 24. System.out.println(); // 每5 个元素一行 25. } 26. } 27.} 数组递增排序

JAVA中运用数组的四种排序方法

JAVA中在运用数组进行排序功能时，一般有四种方法：快速排序法、冒泡法、选择排序法、插入排序法。 快速排序法主要是运用了Arrays中的一个方法Arrays.sort（）实现。 冒泡法是运用遍历数组进行比较，通过不断的比较将最小值或者最大值一个一个的遍历出来。 选择排序法是将数组的第一个数据作为最大或者最小的值，然后通过比较循环，输出有序的数组。 插入排序是选择一个数组中的数据，通过不断的插入比较最后进行排序。下面我就将他们的实现方法一一详解供大家参考。 <1>利用Arrays带有的排序方法快速排序 import java.util.Arrays; publicclass Test2{ publicstaticvoid main(String[] args){ int[] a={5,4,2,4,9,1}; Arrays.sort(a); //进行排序 for(int i: a){ System.out.print(i); } } } <2>冒泡排序算法 publicstaticint[] bubbleSort(int[] args){//冒泡排序算法 for(int i=0;iargs[j]){ int temp=args[i]; args[i]=args[j]; args[j]=temp; } } } return args; } <3>选择排序算法 publicstaticint[] selectSort(int[] args){//选择排序算法 for (int i=0;i

java中数组的定义及使用方法详解

java中数组的定义及使用方法详解 数组：是一组相关变量的集合 数组是一组相关数据的集合，一个数组实际上就是一连串的变量，数组按照使用可以分为一维数组、二维数组、多维数组 数据的有点 不使用数组定义100个整形变量：int i1;int i2;int i3 使用数组定义 int i[100]; 数组定义：int i[100];只是一个伪代码，只是表示含义的 一维数组 一维数组可以存放上千万个数据，并且这些数据的类型是完全相同的，使用java数组，必须经过两个步骤，声明数组和分配内存给该数组，声明形式一 声明一维数组：数据类型数组名[]=null; 非配内存给数组：数组名=new 数据类型[长度]; 声明形式二 声明一维数组：数据类型 [] 数组名=null; java数据类型分为两大类 基本数据类型 int、long操作的时候本身就是具体的内容 引用数据类型：数组、类、接口 引用传递的就是一个内存的使用权，一块内存空间，可能有多个人同

时使用 事例声明数组 package com.qn.array; public class Test { public static void main(String[] args) { int score[]=null;//声明数组 score=new int[3];//开辟空间，大小为3 } } 数组的声明格式里，数据类型是数组元素的数据类型，常见的有整形、浮点型、与字符型等 数组名是用来统一这组相同数据类型元素的名称，其命名规则和变量的相同 数组声明后实际上是在栈内存中保存了此数组的名称，结下了是要在堆内存中配置数组所需要的内存，齐产固定是告诉编译器，所声明的数组要存放多少个元素，而new 则是命令编译器根据括号里的长度 基本数据类型偶读有其默认值：int 0;只要是引用数据类型默认值就是null 事例 package com.qn.array;

Java中数组常用方法的总结

Java中数组常用方法的总结 一、Java标准类库提供static方法System.arraycopy(),用它复制数组比用for循环复制要快得多，System.arraycopy()针对所有的类型做了重载，需要5个参数。 第一个参数：源数组。 第二个参数：偏移量,即从哪个位置开始复制的索引。 第三个参数：目标数组。 第四个参数：偏移量。 第五个参数：要从源数组中复制到目标数组元素的个数,一般情况下为目标数组的长度。 例： 从A数组中复制元素到B数组？ public class Practice { public static void main(String[] args){ String[] A = {"H","e","l","l","o"}; String[] B = new String[3]; System.arraycopy(A, 0, B, 1, B.length - 1); for(int i = 0; i < B.length; i ++){ System.out.print(B[i] + " "); } } } 运行结果为：null H e; 二、Array.Fill(数组名，值)此方法用于填充数组。 例： 现向已知数组A中填充值？ public class Practice { public static void main(String[] args){ String[] A = new String[5]; Arrays.fill(A, "Hello"); for(int i = 0; i < A.length; i ++){ System.out.print(A[i] + " "); } } } 运行结果为： Hello Hello Hello Hello Hello 三、Array.equals(数组名A，数组名B),比较两个数组A、B是否相等，此方法针对所有基本类型与object都作了重载，例如比较两个数是否相等用Integer.equals()方法……，通过object.equals()方法比较数组是否相等，是基于内容的。 例： 三个已知数组的比较？ public class Practice { public static void main(String[] args){ String[] A = {"1","2","3"}; String[] B = {"一","二","三"}; String[] C = {"1","2","3"}; System.out.println(Arrays.equals(A, B)); System.out.println(Arrays.equals(A, C)); } } 运行结果为：false true 四、Array.asList()此方法用于输出数组中的所有数. 例： 输出已知数组A中的所有数？ public class Practice { public static void main(String[] args){ String[] A = {"H","e","l","l","o"};

Java数组练习题(带答案)教学提纲

J a v a 数组练习题 ( 带 答案)

一填空题 1） 数组的元素通过下标来访问，数组Array 的长度为 Array.length 。 2） 数组复制时，"="将一个数组的 引用 传递给另一个数组。 3） JVM 将数组存储在 栈（堆或栈）中。 4） 数组的二分查找法运用的前提条件是数组已经排序 。 5） Java 中数组的下标的数据类型是整型。 6） 数组最小的下标是 0 0 7） arraycopy （）的最后一个参数指明复制元素的个数 。 8） 向方法传递数组参数时，传递的是数组的 引用° 9） 数组初始化包括 数组的申明，创建和初始化 。 10） 数组下标访问超出索引范围时抛出 数组越界 异常 11） 浮点型数组的默认值是 O.Of ° 12） 数组创建后其大小 不能 改变。 二选择题 1. 下面错误的初始化语句是_ABD__ A. char str[]="hello"; B. char str[100]="hello"; C. char str[]={'h','e',T,T,'o'}; D. char str[]={'hello'}; 2. 定义了一维int 型数组a[10]后，下面错误的引用是_B__ 3. A. a[0]=1; B. a[10]=2; C. a[0]=5*2; D. a[1]=a[2]*a[0]; 4. 下面的二维数组初始化语句中，正确的是 _____ 5. A. float b[2][2]={0.1,0.2,0.3,0.4}; B. int a[][]={{1,2},{3,4}}; 6. C. int a[2][]= {{1,2},{3,4}}; D. float a[2][2]={0}; 7. 引用数组元素时，数组下标可以是 _D___ 8. A.整型常量 B.整型变量 C.整型表达式 D.以上均 9. 定义了 int 型二维数组a[6][7]后，数组元素 A. 24 B. 25 C. 18 10. 下列初始化字符数组的语句中，正确的是 __B__ 11. A. char str[5]="hello"; B. char str[]={'h','e',T,T,'o','\0'}; 12. C. char str[5]={"hi"}; D. char str[100]=""; 13. 数组在Java 中储存在丄中 14. A.栈 B.队列 C.堆 D.链表 15. 下面程序的运行结果是 ____ mai n() { int a[][]={{1,2,3},{4,5,6}}; System.out.pri ntf("%d", a[1][1]); } a[3][4]前的数组元素个数为 D. 17

java数组复制的4种方式

java数组复制的4种方式： 第一种方式利用for循环： int[]a={1,2,4,6}; int length=a.length; int[]b=new int[length]; for(int i=0;i

第四种方式： 这里再介绍一下System.arraycopy这个函数，从JAVA API中找了一段。大家看一下。 public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。从src引用的源数组到dest 引用的目标数组，数组组件的一个子序列被复制下来。被复制的组件的编号等于length参数。源数组中位置在srcPos到srcPos+length-1之间的组件被分别复制到目标数组中的destPos到destPos+length-1位置。 如果参数src和dest引用相同的数组对象，则复制的执行过程就好像首先将srcPos到srcPos+length-1位置 的组件复制到一个带有length组件的临时数组，然后再将此临时数组的内容复制到目标数组的destPos到 destPos+length-1位置一样。 If 如果dest为null，则抛出NullPointerException异常。 如果src为null, 则抛出NullPointerException异常，并且不会修改目标数组。

Java基础篇—数组详解

Java基础篇—数组详解 项目开发中，如果需要存储大量的数据，例如如果需要读取100个数，那么就需要定义100个变量，显然重复写100次代码，是没有太大意义的。Java语言提供了数组（array）的数据结构，可以解决这个问题。 数组的概念 一个数组是相同数据类型的元素按一定顺序排列的集合。使用数组可以将同一类型的数据存储在连续的内存位置。数组中各元素的类型相同，通过下标的方式来访问数组中的元素，下标从0开始。 由此得出，数组具有以下基本特点： 数组的长度是确定的，数组一旦被创建，它的大小就是不可以改变的。数组的元素必须是相同类型，不能出现混合类型。数组类型可以是任意数据类型，包括基本数据类型和引用类型。数组在使用之前必须先声明，也就是要先定义后使用。一维数组的定义格式为： 数据类型[]数组名;数据类型数组名[];这两种声明方式完全等价，不过在实际开发中，我们一般推荐使用第一种方式。 数组的初始化 数组声明之后，仅仅是定义了一个数组引用，系统并没有为数组分配任何内存，因此现在还不能访问它的任何元素。必须经过数组初始化后，才能使用数组的元素。 数组的初始化分为静态初始化和动态初始化两种。

静态初始化就是在定义数组的同时给数组元素赋值。静态初始化使用一对大括号将初值括起来，大括号中元素的个数就是数组的长度。格式：数据类型[]数组名=new数据类型[]{元素1,元素2,…}; 例如：int[]arr=new int[]{1,2,3,4}; 动态初始化就是在定义数组时，只指定数组的长度，不为它赋值。在使用到的时候在给它添加元素。格式：数据类型[]数组名=new数据类型[数组长度]; 例如： int[]arr=new int[4]; arr[0]=1; arr[1]=2; arr[2]=3; arr[3]=4; 数组内存图解 首先我们要先了解Java中堆和栈的概念。我们可以这样理解： 我们定义的局部变量都存储在栈中；而堆中存放的都是数组和对象（其实数组也是对象）。凡是new建立的都是在堆中，堆中存放的都是实体（对象），实体可以有多个属性，如果一个数据消失，这个实体没有消失，还可以用，所以堆是不会释放的；但是栈不一样，栈里存放的都是单个变量，变量被释放了，那就没有了。 下面，我们通过对一个数组的声明和初始化的例子来看内存的分配情况。 1.声明一个数组 int[]s=null; 这时，只是声明了一个数组变量，这个变量存储在栈中，堆内存中是不会发生变化的：

实验报告 Java数组与字符串

实验五 Java数组与字符串 【实验目的】 1）掌握数组的声明、分配空间及初始化 2）理解多维数组（重点掌握二维） 3）掌握String类的特点及常用方法的使用 4）掌握StringBuffer类的特点及常用方法的使用 5）掌握String类和StringBuffer类的区别 6）掌握equal方法与==的区别 【实验环境】 JDK1.6+Eclpise3.2 【实验准备】 1）复习课件中理论知识 2）练习课堂所讲的例子 【实验内容】 1、定义一个10个元素组成的一维数组，输出该数组中的最大值、最小值、所有元素总和，以及最大值和最小值在该数组中的位置。 2、编写一个Java程序，完成以下功能： 1）声明一个名为name的String对象，内容是“My name is Networkcrazy”； 2）打印字符串的长度； 3）打印字符串的第一个字符； 4）打印字符串的最后一个字符； 5）打印字符串的第一个单词； 6）打印字符串crazy的位置（从0开始编号的位置）。 3、四位同学中一位做了好事，校长问这四位是谁做的好事。 A说：不是我 B说：是C C说：是D D说：C胡说 已知三个人说的是真话，一个人说的是假话。根据这些信息，找出做好事的人。 【提示】四个人中，每个人均有可能是做好事的人，所以用循环去测试，分别针对每种情形测试说真话的人的个数，如果count值为3，则为要找结果。【实验过程及结果】

1、定义一个10个元素组成的一维数组，输出该数组中的最大值、最小值、所有元素总和，以及最大值和最小值在该数组中的位置。 运行结果

2、编写一个Java程序，完成以下功能： 运行结果： 3、四位同学中一位做了好事，校长问这四位是谁做的好事。 A说：不是我 B说：是C C说：是D D说：C胡说 已知三个人说的是真话，一个人说的是假话。根据这些信息，找出做好事的人。

Java数组操作的10大方法

Java数组操作的10大方法 分享到：更多12 2014-08-27 分类：JAVA、编程开发暂无人评论 本文是码农网原创翻译，转载请看清文末的转载要求，谢谢合作！ 下面是精心整理的Java数组操作的10大方法，大部分代码都来自Stack Overflow。 0、定义一个Java数组 第一种是定义了一个数组，并且指定了数组的长度，我们这里称它为动态定义。 第二种和第三种在分配内存空间的同时还初始化了值。 1、打印Java数组中的元素

这里的重点是说明了Java中数组的引用和值得区别，第三行直接打印intArray，输出的是乱码，因为intArray仅仅是一个地址引用。第4行输出的则是真正的数组值，因为它经过了A rrays.toString()的转化。对Java初学者来说，引用和值仍需重视。 2、从Array中创建ArrayList 为什么要将Array转换成ArrayList呢？可能是因为ArrayList是动态链表，我们可以更方便地对ArrayList进行增删改，我们并不需要循环Array将每一个元素加入到ArrayList中，用以上的代码即可简单实现转换。 3、检查数组中是否包含某一个值 先使用Arrays.asList()将Array转换成List，这样就可以用动态链表的contains函数来判断元素是否包含在链表中。

4、连接两个数组 ArrayUtils是Apache提供的数组处理类库，其addAll方法可以很方便地将两个数组连接成一个数组。 5、声明一个数组内链 6、将数组中的元素以字符串的形式输出 同样利用StringUtils中的join方法，可以将数组中的元素以一个字符串的形式输出。 7、将Array转化成Set集合

java中方法和数组的练习

####计算机与信息技术学院 实验报告 姓名学号专业班级 课程名称 Java实验实验日期 成绩指导教师批改日期实验名称实验3 方法和数组 实验目的： （1）掌握一维数组和二维数组的定义、初始化方法。 （2）了解和初步应用https://www.doczj.com/doc/b215294507.html,ng.Math类的random（）方法处理实际问题。 （3）了解增强for循环，并使用增强for循环顺序访问数组元素。 （4）掌握String类中split方法、charAt方法以及length方法的使用。 （5）掌握Double、Integer等数据包装类的parseDouble、parseInt等方法。 （6）掌握数组的length属性的应用 实验内容： （1）分别用一维数组(例子数组如下{ 7, 4, 3, 9, 0, 6 })实现冒泡排序、选择排序和插入排序中的两种排序算法，程序中要求加注释。 选择排序程序代码： import java.util.*; public class SelectionSort{ public static void sort_1(double []list){ for(int i=0;ilist[min]) min = j; } if(min !=i){ double temp = list[i]; list[i] = list[min]; list[min] = temp; } } } public static void main(String []args){ Scanner input = new Scanner(System.in); System.out.println("请输入要排序的个数："); int num = input.nextInt(); double []list = new double[num]; System.out.println("请输入"+num+"个要排序的数字："); for(int i=0;i