java数组与方法
数组的定义及使用
数组是一组相关数据的集合，一个数组实际上就是一连串的变量，数组按照使用可以分为一维数组、二维数组、多维数组；
一维数组
要使用java的数组，必须经过连个步骤：1、声明数组2、为该数组分配内存
* 声明形式一：
声明一维数组：数据类型数组名[ ]=null；
分配内存给该数组：数组名=new 数据类型[长度];
* 声明形式二：
访问注意：
因为数组的下标是从0开始的，如果索引超出下标的范围，则会抛出https://www.360docs.net/doc/6b17879541.html,ng.ArrayIndexOutOfBoundsException 数组索引越界异常
范例一：判断一组数组中的最大值
冒泡排序法：从小到大排列数组中的元素：
二维数组
二维数组的声明方式和一维数组的类似，内存的分配也一样是用new 关键字。其声明与分配内存的格式如下：
·动态初始化：
1、数据类型数组名[ ] [ ]=null;
2、数组名=new 数据类型[行的个数][列的个数];
·静态初始化：
数据类型数组名[] [ ]={{第0行初始值},{第1行初始值},….{第n行初始值}};
二维数组是数组的数组，若要想取得一个二维数组的长度，则要使用数组名.length，实际上就是数组的行数；若要取得当前数组当前行列的个数，则用数组名[行的个数].length
二维数组的输出要采用嵌套for循环的方式：代码如下
二维数组的静态初始化：
多维数组
经过前面的一维和二维我们已经发现，想要提高数组的维数，只要在声明数组的时候将索引
与括号再加一组即可，所以三维数组的声明方式为：score[ ][ ][ ]；四维数组的声明方式为：score[ ] [ ] [ ] [ ]，以此类推。
方法的声明及使用
方法：方法就是一段可以重复调用的代码段。
1、没有返回值类型，没有参数：修饰符void 方法名(){方法体};
2、没有返回值类型，有参数：修饰符void 方法名(参数类型参数名){方法体};
3、有返回值类型，没有参数：修饰符返回类型方法名(){方法体};
4、有返回值类型，有参数：修饰符返回类型方法名(参数类型参数名){方法体};
5、静态的方法：在修饰符后面添加static即可。
使用static 声明的方法，可以直接类名称.方法名，没有声明的则进行类的实例化
在main方法中直接调用本类中的静态方法：
方法的重载
方法的重载就是方法名称相同，但参数的类型和参数的个数不同，通过传递参数的个数及类型不同以完成不同功能的方法调用。
方法重载的具体实现代码如下：
提示：System.out.println();本身也是属于方法的重载；方法的重载的注意事项：一定只是在参数的类型或个数不同
补充：在java面试中经常会遇到方法的重写与重载的不同
方法的重写：类继承父类，并在子类中定义一个与父类中的方法名称和参数都相同的方法（返回类型可以不同）就会覆盖父类中的方法，叫做方法的重写。并且重写只有在具有继承关系的类中出现
使用return结束一个方法
return 可以返回一个方法的结果，在java中也可以使用return结束一个方法
方法的递归调用
递归调用是一种特殊的调用形式，是方法自己调用自己。
下面采用方法的递归完成数字的累加功能：
出。
方法的递推
递推就是利用循环迭达的方法一步一步进行计算，知道达到目的，它是属于数学中的的函数，也叫做递推数列
递归与递推的比较：
递归要进行函数的调用，是在于压栈和出栈的操作这是主要的开销，但是递推就不用函数的栈操作只是运用数学上的函数，所以两者运行起来的话，递推的方式效率和性能比较高一些，但是有些功能递推是实现不了的。
下面是常用的递归和递推的例子：（来源网络）
最好的例子是斐波那契数列: 1 1 2 3 5 8 13 21 ... ...
总结成公式就是F(n+1)=F(n)+F(n-1), F(0)=F(1)=1;
你可以用递归的方法写这个函数:
int F(int n) {
if (n <2) return 1;
else return F(n-1)+F(n-2);
}
但也可以用递推的方式:
int F(int n) {
if (n <2) return 1;
int f0=1, f1=1, f;
for (int i=0; i f=f0+f1; f1=f; f0=f1; } } 显然能用递推的话就用递推, 一般肯定要比递归快,除非有的问题不用递归做不出来的. 线性规划法在推导时往往是用递归的形式,但最后可以化为递推 数组的引用传递 一个方法可以接收一个数组，也可以返回一个数组，如果一个方法接收一个数组的话，则此方法对数组的修改最终都会被保留下来 的说明返回类型是数组即可。代码如下： 数组拷贝 可以将一个数组的内容拷贝到另外一个数组，如果要实现这种设计，则应该传递的参数为：1、源数组2、源数组的开始点3、目标数组4、目标数组的开始点5、拷贝的长度 实现代码如下： 始点(int)，目标数组(数组名)，目标数组的开始点(int)，拷贝的长度(int));具体如下： Java新特性对数组的支持 可变参数 在调用一个方法的时候，必须根据方法的定义传递指定的参数，但是在JDK1.5之后产生了新的概念—可变参数，即：方法中接收的参数不再是固定的，而是随着需要传递的，可变参数的定义格式如下： 返回值类型方法名称(类型…参数名称)； 注：所有的可变参数接收之后都是以数组的形式保存下来的，所以直接按数组的方式接收 foreach输出 数组的输出，一般都会采用for循环进行输出，但在JDK1.5之后为了方便数组的输出，提供了一种foreach语法，其格式如下： 变参数的时候 2、Foreach不只是可以输出在以后的类集中也是有输出能力的 西安邮电大学 （计算机学院） 课内实验报告 实验名称：数组与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相同"); } 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 )—原因：子类继承父类，并且可以有自己的成员变量和成员方法。所以可以认为子类是父类的扩展。 1.插入排序 算法思想 插入排序使用了两层嵌套循环，逐个处理待排序的记录。每个记录与前面已经排好序的记录序列进行比较，并将其插入到合适的位置。假设数组长度为n，外层循环控制变量i 由1至n-1依次递进，用于选择当前处理哪条记录；里层循环控制变量j，初始值为i，并由i至1递减，与上一记录进行对比，决定将该元素插入到哪一个位置。这里的关键思想是，当处理第i条记录时，前面i-1条记录已经是有序的了。需要注意的是，因为是将当前记录与相邻的上一记录相比较，所以循环控制变量的起始值为1（数组下标），如果为0的话，上一记录为-1，则数组越界。 现在我们考察一下第i条记录的处理情况：假设外层循环递进到第i条记录，设其关键码的值为X，那么此时有可能有两种情况： 1.如果上一记录比X大，那么就交换 它们，直到上一记录的关键码比X 小或者相等为止。 2.如果上一记录比X小或者相等，那 么之前的所有记录一定是有序的， 且都比X小，此时退出里层循环。 外层循环向前递进，处理下一条记 录。 算法实现(C#) public class SortAlgorithm { // 插入排序 public static void InsertSort for (int i = 1; i <= array.Length - 1; i++) { //Console.Write("{0}: ", i); int j = i; while (j>=1 && https://www.360docs.net/doc/6b17879541.html,pare(array[j], array[j - 1]) < 0) { swap(ref array[j], ref array[j-1]); j--; } //Console.WriteLine(); //AlgorithmHelper.PrintArray(arr ay); } } // 交换数组array中第i个元素和第j个元素 private static void swap 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.360docs.net/doc/6b17879541.html,="豆浆机"; Product p2=new Product(); https://www.360docs.net/doc/6b17879541.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 C语言中数组排序算法及函数调用 一、冒泡法（起泡法） 算法要求：用起泡法对10个整数按升序排序。 算法分析：如果有n个数，则要进行n-1趟比较。在第1趟比较中要进行n-1次相邻元素的两两比较，在第j趟比较中要进行n-j次两两比较。比较的顺序从前往后，经过一趟比较后，将最值沉底（换到最后一个元素位置），最大值沉底为升序，最小值沉底为降序。 算法源代码： # include 一填空题 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的长度为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() { 个人对这8种排序算法的理解,希望对大家有点帮助. 趁自修时间,自己将这8种排序的代码写了一下....... 1.简单的选择排序 bool selectionsort(int *array,int n) //array为存储数据的数组,n为数组元素个数 { int k,temp; //k用来存储,临时最小数据的位置 for(int i=0;i for(int i=1;i 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语言中，不可以将数组直接赋值给另一个数组； 数据结构实训报告 实验名称：数据结构 题目：内部排序比较 专业：班级：姓名：学号：实验日期： 一、实验目的：通过随机数据比较各内部排序算法的关键字比较次数和关键字移动的次数，以取得直观感受。训练学生综合设计算法能力。 二、实验要求：待排序长度不小于100，数据可有随机函数产生，用五组不同输入数据做比较，比较的指标为关键字参加比较的次数和关键字移动的次数；对结果做简单的分析，包括各组数据得出结果的解释；设计程序用顺序存储。 三、实验内容 1、待排序表的表长不小于100；至少要用5组不同的输入数据作比较；排序算法不少于3种； 2 、待排序的元素的关键字为整数； 3 、比较的指标为有关键字参加的比较次数和关键字的移动次数(关键字交换以3次计)。 4、演示程序以人机对话的形式进行。每次测试完毕显示各种比较指标的列表，以便比较各种排序的优劣。 5、最后要对结果作简单的分析。 6、测试数据：用伪随机数产生程序产生。 四、实验编程结果或过程： 1. 数据定义 typedef struct { KeyType key; }RedType; typedef struct { RedType r[MAXSIZE+1]; int length; }SqList; 2. 函数如下，代码详见文件“排序比较.cpp” int Create_Sq(SqList &L) void Bubble_sort(SqList &L)//冒泡排序void InsertSort(SqList &L)//插入排序 void SelectSort(SqList &L) //简单选择排序int Partition(SqList &L,int low,int high) void QSort(SqList &L,int low,int high)//递归形式的快速排序算法 void QuickSort(SqList &L) void ShellInsert(SqList &L,int dk)//希尔排序 void ShellSort(SqList &L,int dlta[ ]) 3. 运行测试结果，运行结果无误，如下图语速个数为20 精心整理一填空题 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.数组复制是数组引用的传递 各种排序方法复杂度总结归纳 一、冒泡排序 主要思路是： 通过交换相邻的两个数变成小数在前大数在后，这样每次遍历后，最大的数就“沉”到最后面了。重复N次即可以使数组有序。 代码实现 void buadfdsle_sort（int arr[]，int len） { for （int i = 0; i { for （int j = len —1; j >= i; j——） { if （arr[j] { int temp = arr[j]; arr[j] = arr[j —1]; arr[j —1] = temp; } } } } 冒泡排序改进1： 在某次遍历中，如果没有数据交换，说明整个数组已经有序，因 此通过设置标志位来记录此次遍历有无数据交换就可以判断是否要继续循环。 冒泡排序改进2： 记录某次遍历时最后发生数据交换的位置，这个位置之后的数据显然已经有序。因此设置标志位记录每次遍历中最后发生数据交换的位置可以确定下次循环的范围。 二、直接插入排序 主要思路是： 每次将一个待排序的数组元素，插入到前面已排序的序列中这个元素应该在的位置，直到全部数据插入完成。类似扑克牌洗牌过程。 代码实现 void _sort（int arr[]，int len） { for （int i = 1; i { int j = i —1; int k = arr[i]; while （j > —1 && k { arr[j + 1] = arr[j]; j ——; } arr[j + 1] = k; } } 三、直接选择排序 主要思路是： 数组分成有序区和无序区，初始时整个数组都是无序区，每次遍历都从无序区选择一个最小的元素直接放在有序区最后，直到排序完成。 代码实现 void select_sort（int arr[]，int len） { for （int i = 0; i { int index = i; for （int j = i + 1; j { if （arr[j] index = j; } if （index ！= i） { int temp = arr[i]; arr[i] = arr[index]; arr[index] = temp; } } } 冒泡排序法 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.} 数组递增排序 第三节数值型一维数组的应用 一、数值型一维数组在递推中的应用 【例5-3】斐波拉契数列：前两项为0和1，从第三项开始，各项均为前相邻两项之和：0，1，1，2，3，5，8，11，19，……。写C程序，输出该数列前N项。 【简要分析】显然这是一个典型的递推问题，结合数组，从第三个数开始，其递推公式是： x[i]=x[i-1]+x[i-2]，其中i=2,3, …,N-1。 利用循环结构，用N-S流程图描述的程序逻辑如图5-2所示。 参考源代码： /* 例5-3，5-3.cpp */ #include for ( i = 2; i < N; i++ ) /* 尚剩18项*/ x[i] = x[i - 1] + x[i - 2]; /* 产生各项*/ for ( i = 0; i < N; i++ ) /* 输出数列*/ cout<< "\t" << x[i]; system(“pause”); } 【思考验证】如果将x数组定义为整型int，程序是否能正常运行？ 【模仿训练】某数列前三项为0、1、1，以后各项均为前相邻三项之和，输出该数列前N项。 二、排序 【例5-4】键盘输入N个战士的身高，将其升序排列。 【简要分析】排序是数组的经典应用，现实生活中用得太多，请读者务必掌握。排序的方法很多，《数据结构》中有详细介绍，请读者自己查阅，本例用比较法。 具体实现逻辑是：将数组元素a[i]（i=0,1,2…,N-2）与它后边的每一个元素a[j]（j=i+1,…,N-1）逐个比较，凡有a[j] 数组与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 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;i 若想要存放一连串相同数据类型的数据，使用数组是个相当好用的选择。此外，如果某个程序片段经常反复出现，那么将它定义成一个方法可以有效地简化程序代码。本章主要是介绍数组的基本用法与方法的应用，学完本章，将会对数组与方法的使用有更深一层的认识。 数组是由一组相同类型的变量所组成的数据类型，它属于引用类型。它们以一个共同的名称表示，数组中的每个元素则以下标来访问。数组依照存放元素的复杂程度分为一维数组、二维和多维数组，先来看看一维数组。 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.知识点 一维数组：定义、初始化、使用（相关的算法，常用系统类的使用） 多维数组：定义、初始化、使用 增强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这个引用变量 *一般我们的程序在运行时，我们为局部变量在栈中开辟内存，而为对象(对象属性)在堆中开辟内存。为对象方法在方法区开辟内存空间。为类的属性，在静态区开辟内存空间。 具体的内存图： /* 数组排序 */ 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 本文由我司收集整编，推荐下载，如有疑问，请与我司联系 java 中数组常见的排序问题整理 2016/03/13 0 span > 1.选择排序：选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的 起始位置，直到全部待排序的数据元素排完。选择排序是不稳定的排序方法。 如图所示：数组array 有5 个元素 首先，array[0]与array[1]比较大小，如果array[0] array[1],则将两元素互换位置，然后再将array[0]与array[2]进行比较，一次进行下去，当第一轮循环完成，则 array[0]是数组中最小的元素。然后开始拿array[1]与array[2]进行比较，依次下去， 比较到最后即可。 程序代码实现如下： public void SelectionSort(int[] array){for(int i=0;i array.length-1;i++){for(int j=i+1;j array.length;j++){int temp;if(array[i] array[j]){temp = array[i];array[i]=array[j];array[j]=temp;}}}}2.冒泡排序：它重复地走访过要排序的数 列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作 是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。下面用一张图 来详细说明冒泡的原理。如图： 数组array 有五个元素，int[] array={7,5,12,9,2}; 第一步还是和选择排序一样，先是array[0]和array[1]进行比较，如果array[0] array[1],两个元素互换位置，即array[0]=5,array[1]=7；第二步，array[1]和array[2]进行比较大小，array[1] array[2],位置不变；第三步，array[2]和array[3]比较，array[2] array[3],位置互换；array[3]与array[4]比较，array[3] array[4],位置互换，第一轮循环结束，我们会发现，数组的最后一个元素是数组中最大的。第一轮循环完成后的数 组变成如下图所示： 接下来继续又从array[0]和array[1]开始比较，重复下去。第一轮比较得出了最Java数组与Java基础类实验报告
JAVA类与对象及数组习题及答案
四种简单的排序算法
Java类 类型的数组创建与使用方法
C语言中数组排序算法及函数调用
Java_数组练习题目
Java数组练习题(带答案)
8种排序算法(有代码)
java数组的概念和作用
数据结构内部排序比较分析
Java数组测习题(带答案)
各种排序方法复杂度总结归纳
JAVA数组的排序方法实例
C++一维数组的排序
JAVA数组与List之间相互转换的方法详解
JAVA中运用数组的四种排序方法
Java数组与方法
java中数组的学习完整版一
JAVA基础练习程序 数组冒泡排序
java中数组常见的排序问题整理