有30个0~9之间的数字，分别统计0~9这10个数字分别出现了多少次Public class TestArray
{
int score[]={0,0,1,2,3,5,4,5,2,8,7,6,9,5,4,8,3,1,0,2,4,8,7,9,5,2,1,2,3,9};
int num0=0;
int num1=0;
int num2=0;
int num3=0;
int num4=0;
int num5=0;
int num6=0;
int num7=0;
int num8=0;
int num9=0;
for (int i=0;i { if (score[i]==9) { num9++; } if (score[i]==1) { num1++; } if (score[i]==2) { num2++; } if (score[i]==3) { num3++; } if (score[i]==4) { num4++; } if (score[i]==5) { num5++; } if (score[i]==6) { num6++; } if (score[i]==7) { num7++; } if (score[i]==8) { num8++; } if (score[i]==0) { num0++; } } System.out.println("0出现的次数："+num0); System.out.println("1出现的次数："+num1); System.out.println("2出现的次数："+num2); System.out.println("3出现的次数："+num3); System.out.println("4出现的次数："+num4); System.out.println("5出现的次数："+num5); System.out.println("6出现的次数："+num6); System.out.println("7出现的次数："+num7); System.out.println("8出现的次数："+num8); System.out.println("9出现的次数："+num9); } 定义一个整型数组，保存10个数据，利用程序完成将最大值保存在数组中的第1个元素且原第一个数换到最大值的位置！ public class TestArray01 { public static void main(String agrs[]) { int score[]={55,45,5,44,2,6,56,15,4,12}; System.out.println("这10个数字："); print(score); System.out.println(""); System.out.println("改变后的数字："); add(score); } public static void add(int score[]) { int max=score[0]; int arr[]=new int[score.length]; for (int i=0;i { arr[i]=score[i]; if (max { max=arr[i]; int temp=arr[0]; arr[0]=arr[i]; arr[i]=temp; } } for (int i=0;i { System.out.print(arr[i]+"、"); } } public static void print(int arr[]) { for (int i=0;i { System.out.print(arr[i]+"、"); } } } 在排序好的数组中添加一个数字，将添加后的数字插入到数组合适的位置。 import java.util.Scanner; public class TestArray02 { public static void main(String agrs[]) { int score[]={5,10,20,40,42,100,500}; System.out.println("原数组为："); print(score); System.out.println(""); System.out.println("输入要插入的数字"); Scanner scan=new Scanner(System.in); int x=scan.nextInt(); System.out.println("添加一个数字后，数组的排序为："); add(x,score); } public static void print(int arr[]) { for (int i=0;i { System.out.print(arr[i]+"、"); } } public static void add(int y,int arr[]) { int one[]=new int[arr.length+1]; for (int i=0;i { one[i]=arr[i]; } one[one.length-1]=y; for (int i=1;i { for (int j=0;j { if (one[i] { int temp=one[i]; one[i]=one[j]; one[j]=temp; } } } for (int i=0;i { System.out.print(one[i]+"、"); } } } 编写程序求1！+2！+.........30！的和并显示Public class TestArray { public static void main(String agrs[]) { double i=1; double sum=0; double s=1; for (i=1;i<=30 ;i++ ) { s=s*i; sum=sum+s; } System.out.print(sum); } } ●定义一个由整数组成的数组，要求求出其中的奇数个数和偶数个数。 public class TestArray03 { public static void main(String agrs[]) { int n=0; int m=0; int score[]={12,125,22,5,7,6,8,11,20}; for (int i=0;i { if (score[i]%2==0) { n++; }else { m++; } } System.out.println("偶数的个数："+n); System.out.println("奇数的个数："+m); } } ●现在定义如下的一个数组：int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5},要求将以上数组 中值为0的去掉，将不为0的值存入一个新的数组，生成的新数组为：int newArr[]={1,3,4,5,6,6,5,4,7,6,7,5} public class TestArray04 { public static void main(String agrs[]) { int oldArr[]={1,3,4,5,0,0,6,6,0,5,4,7,6,7,0,5}; int k=0; int num=0; for (int i=0;i { if (oldArr[i]==0) { num++; } } int newArr[]=new int[oldArr.length-num]; for (int i=0;i { if (oldArr[i]!=0) { newArr[k]=oldArr[i]; k++; } } for (int i=0;i { System.out.print(newArr[i]+"、"); } } } //定义一个整型数组，求出数组元素的和、数组元素的最大值和最小值，并输出所求结果。 public class TestArray05 { public static void main(String agrs[]) { int score[]={22,11,33,15,23,12,14,55}; int k=0; int max=score[0]; int min=score[0]; for (int i=0;i { k=k+score[i]; if (max { max=score[i]; } if (min>score[i]) { min=score[i]; } } System.out.println("数组的和："+k); System.out.println("数组的最大数："+max); System.out.println("数组的最小数："+min); } } ●//给出10个整数（int型），然后任意查询一个数字是否存在该10个数字内 public class TestArray06 { public static void main(String[] args) { int score[]={11,12,33,15,55,45,66,65,78,88}; int sum=11; for (int i=0;i { if (sum==score[i]) { System.out.print("sum是这10个数里的数为："+sum); break; } else { System.out.print("sum不是这10个数里的数！"); break; } } } } ●//定义一个包含10个元素的数组，对其进行赋值，使每个元素的值等于其下标，然后 输出；最后将这个数组倒置后输出 public class TestArray07 { public static void main(String[] args) { int score[]=new int[10]; int arr[]=new int[score.length]; System.out.println("数组改变前："); for (int i=0;i { score[i]=i; System.out.print(score[i]+"、"); } System.out.println("\n"+"数组改变后："); for (int i=0;i { arr[i]=score[i]; } for (int i=0;i { score[i]=arr[score.length-1-i]; System.out.print(score[i]+"、"); } } } //给出10个老师的打分，对10个老师的打分打到最高分public class TestArray08 { public static void main(String[] args) { int score[]={100,33,15,95,11,23,54,23,45,86}; int max=score[0]; for (int i=0;i { if (max { max=score[i]; } } System.out.println("老师打的最高分:"+max); } } 一填空题 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. 链表 一填空题 1)数组的元素通过来访问，数组Array的长度为。 2)数组复制时，"="将一个数组的传递给另一个数组。 3)没有显式引用变量的数组称为数组。 4)JVM将数组存储在(堆或栈)中。 5)数组的二分查找法运用的前提条件是数组已经。 6)矩阵或表格一般用维数组表示。 7)如果把二维数组看成一维数组，那么数组的元素是数组。 8)Java中数组的下标的数据类型是。 9)不用下标变量就可以访问数组的方法是。 10)数组最小的下标是。 11)arraycopy()的最后一个参数指明。 12)向方法传递数组参数时，传递的是数组的。 13)线性查找法的平均查找长度为。 14)数组初始化包括。 15)数组下标访问超出索引范围时抛出异常 16)浮点型数组的默认值是。 17)对象型数组的默认值是。 18)对象类型的数组虽然被默认初始化，但是并没有构造函数。 19)二维数组的行的长度不同。 20)数组创建后其大小改变。 二选择题 1.下面错误的初始化语句是___ 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]后，下面错误的引用是___ 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.引用数组元素时，数组下标可以是____ A. 整型常量 B. 整型变量 C. 整型表达式 D. 以上均可 5.定义了int型二维数组a[6][7]后，数组元素a[3][4]前的数组元素个数为____ A. 24 B. 25 C. 18 D. 17 6.下列初始化字符数组的语句中，正确的是____ 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中储存在中 一填空题 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() { 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语言中，不可以将数组直接赋值给另一个数组； 若想要存放一连串相同数据类型的数据，使用数组是个相当好用的选择。此外，如果某个程序片段经常反复出现，那么将它定义成一个方法可以有效地简化程序代码。本章主要是介绍数组的基本用法与方法的应用，学完本章，将会对数组与方法的使用有更深一层的认识。 数组是由一组相同类型的变量所组成的数据类型，它属于引用类型。它们以一个共同的名称表示，数组中的每个元素则以下标来访问。数组依照存放元素的复杂程度分为一维数组、二维和多维数组，先来看看一维数组。 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所示。 习题1. 数据类型转换应用 【案例简介】下例说明了整型、浮点型、字符串型之间的相互转换。 【案例目的】掌握Java中两个不兼容类型能够的数据格式之间的转换。 【技术要点】高精度到低精度的数据转换时候需要进行强制转换，低精度向高精度进行转换的时候的会自动进行，字符串到其他类型的转换需要用到特定的方法。 【代码分析】 public class Conversation { public static void main(String [] args) { String str = "123"; int j; byte b; int i=257; double d = 323.142; System.out.println("\nConversion of int to byte."); //i强制转换成byte型 System.out.println("i and b "+ i + " "+b); System.out.println("\nConversion of double to int."); //d强制转换成int型 System.out.println("d and i "+ d + " "+i); //d强制转换成byte型 System.out.println("d and b "+ d + " "+b); j=Integer.parseInt(str); //str转换成int型 System.out.println("j="+j); } } 【相关知识】 数据类型转换 （1）简单数据类型中各类型数据间的优先关系和相互转换 不同类型数据间的优先关系如下 低----------------------------------------------->高 byte->short->char-> int -> long -> float -> double 自动类型转换规则 整型，实型，字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算，转换从低级到高级。 （2）强制类型转换 高级数据要转换成低级数据，需用到强制类型转换，如： int i; byte b=(byte)i; //把int型变量i强制转换为byte型 （3）其他转换 数字变为字符串 用如下方法转换相应类型的数字： Double.toString(double)； Float.toString(float); 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中，数组是独立的对象，有自身的方法，不是变量的集合。 数组的声明： 类型标识符数组名[ ] 或者类型标识符[] 数组名。 数组的长度是在创建的时候决定的。 数组的创建方法： 先声明后创建： int array[]; array = new int[10]; 在声明的同时创建： int array[] = new int[10]; 直接赋值： int array[]= new int[1,2,3,4]; 数组下标从0开始。 数组是引用类型，他的元素相当于类的成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被隐士地初始化。如： public class Testpublic static void main(Stirng [] args)?? int [] a = new int [5]; ?? Date[] days=new Date[3]; ?? System.out.println(a[3]); ?? System.out.println(days[2]);} class Dateint year,month,day; Date(int year,int month,int day)?? this.year=year; ?? this.month=month; ?? this.day=day;} 结果将是：0????? null 数组的拷贝 最有效率的方法是使用https://www.doczj.com/doc/942937607.html,ng.System类的静态方法： public static void arraycopy(object src,int srcPos,object dest, ???????????????? int destPos,int length) 可以用于数组src从第srcPos项元素开始的length个元素拷贝到目标数组从destPos项开始的length个位置。 如果源数据数目超过目标数组的边界，系统就会抛出异常。 二维数组 float[][] numthree;???????????? //定义一个float类型的2维数组 numthree=new float[5][5];?????? //为它分配5行5列的空间大小 numthree[0][0]=1.1f;??????????? //通过下标索引去访问???? 1行1列= 1.1 numthree[1][0]=1.2f;????????????????????????????????? // 2行1列=1.2 numthree[2][0]=1.3f;????????????????????????????????? // 3行1列=1.3 numthree[3][0]=1.4f;????????????????????????????????? // 4行1列=1.4 学号 Java语言程序设计C 实验报告 实验2 数组及常用算法 学生姓名 专业、班级 指导教师 成绩 计算机与信息工程学院 年月日 一、实验目的 学习课程相关章节知识，通过上机练习，掌握以下知识： 1．掌握Java中对象和引用变量的概念 2．掌握Java数组的使用和本质 3．掌握数组相关常用算法（复制及排序方法） 二、实验内容 写一个方法，功能：定义一个一维的int 数组，长度为10，把从控制台输入整数赋值给数组,然后将它们按从小到大的顺序输出（使用冒泡排序）（知识点：数组遍历、数组元素访问） 三、实验思想 1．Java中对象和引用变量的概念 2．Java数组的使用和本质 3．数组相关常用算法（复制及排序方法） 四、实验结果 package sss; import java.util.Scanner; public class aaa { public static void main(String[] args) { // TODO自动生成的方法存根 Scanner input=new Scanner(System.in); System.out.println("排序之前的数组："); int a[]=new int[10]; for(int b=0;b 一填空题 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___ 精心整理一填空题 1)数组的元素通过下标来访问，数组Array的长度为Array.length。 2)数组复制时，"="将一个数组的引用传递给另一个数组。 3)JVM将数组存储在栈(堆或栈)中。 4)数组的二分查找法运用的前提条件是数组已经排序。 5)Java中数组的下标的数据类型是整型。 6)数组最小的下标是0。 7) 8) 9) 10) 11) 12) 1. 2. 3. 4. 5. 6. 7. 8.A. 9. 10. 11.A 12.C.charstr[5]={"hi"}; D.charstr[100]=""; 13.数组在Java中储存在C中 14.A.栈 B.队列 C.堆 D.链表 15.下面程序的运行结果是____ main(){ inta[][]={{1,2,3},{4,5,6}}; } A.3 B.4 C.5 D.6 16.下面程序的运行结果是_C___ 17.m ain(){ intx=30; int[]numbers=newint[x]; x=60; (numbers.length); } A.60 B.20 C.30 D.50 18. 19.m 20.c 21.i 22.w 23. 24.A 25.C 26. A. C.用 27. 28. A. 29. 30. 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.数组复制是数组引用的传递 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; JA V A基础语法_数组 一、选择题 1、以下能对二维数组a进行正确初始化的语句是 A）int a[2][] = { {1 , 0 , 1} , {5 , 2 , 3} }; B）int[][] a = { { 1, 2, 3 }, { 4, 5, 6 } }; C）int a[2][4] = { { 1 , 2 , 3 }, { 4 , 5 } , { 6 } }; D）int[] a = { { 1 , 0 , 1 } { } , { 1 , 1 } }; 答案:B 2、若有说明：int a[][]=new int[2][3];则数组a中各元素 A）可在程序的运行阶段得到初值0 B）可在程序的编译阶段得到初值0 C）不能得到确定的初值 D）可在程序的编译或运行阶段得到初值0 答案:A 3、下面创建二维数组正确的是 A）int[][] a = new int[][3]; B）int[][] a = new int[2][3]; C）int[] a[] = new int[2][]; D）int a[][] = new int[][2]; 答案:BC 4、若有说明： int a[] = { 1, 2, 3, 4, 5, 6, 7 }; 则获取a数组的大小是A）length B）length() C）getLen() D）size() 答案:A 5、执行下面的程序段后,变量k中的值为 int k = 3, s[] = new int[2]; s[0] = k; k = s[1] * 10; A）0 B）33 C）30 D）10 答案:A 6、下列四个选项中，正确的数组定义是______ A）int size = 2; int[] a = new int[size]; B）int 3a = new int[3]; C）long size = 2; int[] a = new int[size]; D）int[] $a= new int[3]; 答案:AD 编程题 1.将整型数组a赋值初值（含5个元素），并求出a中的最大元素和最小元素public class test { public static void main(String[] args) { int[] nums = { 2, 1, 4, 100, 88,}; <―灰色部分5个元素大家随意写，别写的一样的就行了for (int i = 0; i <= nums.length - 1; i++) { for (int j = i + 1; j <= nums.length - 1; j++) { if (nums[i] > nums[j]) { int temp = nums[i]; nums[i] = nums[j]; nums[j] = temp; } } } System.out.println("最小值为:" + nums[0] ) ; System.out.println("最大值为:" + nums[nums.length - 1]); } } 2．已知a是整型数组，编程求出a中的最大元素和最先元素 import java.util.ArrayList; import java.util.Collections; import java.util.List; public class Test{ public static void main(String[] args) { List list = new ArrayList(); for (int i = 0; i < 10; i++) { list.add((int) (Math.random() * 100)); } System.out.println(list); Collections.sort(list); System.out.println("最大值是:" + list.get(list.size() - 1)); System.out.println("最小值是:" + list.get(0)); } } 3.输入整数n，并计算从1到n的累加和 import java.util.Scanner; public class Test{ public static void main(String args[]){ Scanner scan = new Scanner(System.in); int count = 0; 1、编写一个简单程序，要求数组长度为5，分别赋值10，20，30，40，50，在控制台输出该数组的值。（知识点：数组定义和创建、一维数组初始化）public class work01 { public static void main(String[] args) { // TODO Auto-generated method stub int arr[] = new int[]{10,20,30,40,50}; for(int i = 0;i<=arr.length;i++){ System.out.println(arr[i]); } } } 运行结果： 2、将一个字符数组的值（neusofteducation）拷贝到另一个字符数组中。（知识点：数组复制） public class work02 { public static void main(String[] args) { // TODO Auto-generated method stub char[] copyFrom = new char[]{'n','e','u','s','o','f','t','e', 'd','u','c','a','t','i','o','n'}; char[ ] copyTo = new char[16]; System.arraycopy(copyFrom, 0, copyTo, 0, 16); System.out.println(new String(copyTo)); } } 运行结果： 3、给定一个有9个整数（1,6,2,3,9,4,5,7,8）的数组，先排序，然后输出排序后的数组的值。（知识点：Arrays.sort排序、冒泡排序） public class work03 { public static void main(String[] args) { // TODO Auto-generated method stub int[ ] point = {1,6,2,3,9,4,5,7,8}; java.util.Arrays.sort( point ); for(int i=0;i /* 数组排序 */ public class BubbleSort { public static void main(String[] args){ int[] arr = {1,25,36,21,24,12,39,87}; System.out.println("排序前："); String str = array2string(arr); System.out.println(str); bubblesort(arr); System.out.println("排序后："); String str2 = array2string(arr); System.out.println(str2); } /*冒泡排序*/ public static void bubblesort(int[] arr){ for(int x=0;x //定义二维数组写法1 class numthree { public static void main(String[] args) { float[][] numthree; //定义一个float类型的2维数组 numthree=new float[5][5]; //为它分配5行5列的空间大小 numthree[0][0]=1.1f; //通过下标索引去访问 1行1列=1.1 numthree[1][0]=1.2f; // 2行1列=1.2 numthree[2][0]=1.3f; // 3行1列=1.3 numthree[3][0]=1.4f; // 4行1列=1.4 numthree[4][0]=1.5f; // 5行1列=1.5 System.out.println(numthree[0][0]); //打印换行输出喽 System.out.println(numthree[1][0]); System.out.println(numthree[2][0]); System.out.println(numthree[3][0]); System.out.println(numthree[4][0]); } } //定义二维数组写法2 定义的同时分配空间大小 class numfour { public static void main(String[] args) { short[][] numfour=new short[5][8]; //定义一个short类型的数组同时为它分配5行8列的空间大小 numfour[0][7]=10; numfour[1][6]=20; numfour[2][5]=30; numfour[3][4]=40; numfour[4][3]=50; System.out.println(numfour[0][7]); System.out.println(numfour[1][6]); System.out.println(numfour[2][5]); System.out.println(numfour[3][4]); System.out.println(numfour[4][3]); } } //定义二维数组写法3 不规则数组 class numfive 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___ 1.类型转换例子：double d = Double.parseDouble(放入需要转换的值); 2.//获取1970.1.1零时到此时此刻的毫秒数 long a = System.currentTimeMillis(); 3.int num=(int)(Math.random()*1000+1); //生成1到1000之内的随机数将字符串转成小写String str = "aGDa"; str = str.toLowerCase(); 4.将字符串转成大写toUpperCase() 5.字符串不区分大小写比较str.equalsIgnoreCase(anotherString) 6.区分大小写比较str.equals() 数组 7.数组的定义 int[] arr = new int[10]; 8.数组的初始化 int[] arr1 = new int[3]; //0,0,0 第一种方式 int[] arr2 = {1,4,7}; //1,4,7 第二种方式 int[] arr3 = new int[]{1,4,7}; //1,4,7 第三种方式 int[] arr; arr = {1,4,7}; //编译错误 arr = new int[]{1,4,7}; //正确 arr = new int[10]; //正确 9.数组的访问 a) 通过数组名.length获取数组的长度 int[] arr = new int[3]; System.out.println(arr.length);//3 b) 通过下标/索引来访问数组中的元素下标从0开始，最大到数组.length-1 int[] arr = new int[3]; arr[0] = 100; //给arr中的第一个元素赋值为100 arr[1] = 200; //给arr中的第二个元素赋值为200 arr[2] = 300; //给arr中的第三个元素赋值为300 arr[3] = 400; //异常(数组下标越界) System.out.println(arr[arr.length-1]);//输出数组中的最后一个元素 arr[arr.length-1] = 800; 10.数组的遍历 int[] arr = new int[3];//定义一个数组 for(int i=0;iJava_数组练习题目
Java-数组练习题目(汇编)
Java数组练习题(带答案)
java数组的概念和作用
Java数组与方法
java第三章上机练习题
java中数组的学习完整版一
Java中数组的声明
Java实验报告-数组及常用算法
Java数组练习题(带答案)
Java数组测习题(带答案)
java中数组的定义及使用方法详解
JAVA基础语法数组
java复习题及答案
java编程基础—数组练习
JAVA基础练习程序 数组冒泡排序
java定义二维数组的几种写法
Java数组练习题(带答案)教学提纲
Java干货分享,数组的定义,初始化,数组的遍历
相关主题
文本预览