Java在原数组中插入一个元素,并按升序排列

Java在原数组中插入一个元素,并按升序排列
Java在原数组中插入一个元素,并按升序排列

Java在原数组中插入一个元素,并按升序排列

1.效果图

2.源代码

package LianXi;

import java.util.Arrays;

import java.util.Scanner;

public class ChanRuYuanSu {

/**

@描述:

* @方法名称:main---->shangji_3_p162_.java

* @作者:Java - wangzhe

* @创建日期:2016-6-26下午06:08:01

* @param args

* @param args

*/

public static void main(String[] args) {

Scanner input = new Scanner(System.in);

//原数组

int num[]=new int[]{1,4,6,8};

//新建数组

int nums[]=new int [num.length+1];

//将原数组排序

Arrays.sort(num);

//遍历原数组至新数组

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

nums[i]=num[i];

}

//友好提示要插入的新数字

System.out.print("请输入您要插入的新数字:");

//接受用户输入

int num1= input.nextInt();

//插入的数组在新数组中的下标

int index =num.length;

//for循环遍历找到要插入数字的下标

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

if (num1

index=i;

break;

}

}

System.out.println("要插入元素的下表为:"+index);

//将元素后移

for (int j = nums.length-1; j > index; j--) {

nums[j] = nums[j-1];

}

//插入数字

nums[index] = num1;

//for循环遍历输出新数组

//插入后的数组为

System.out.println("插入后的数组为:");

for (int k = 0; k < nums.length; k++) {

System.out.print(nums[k]+"");

}

}

}

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.360docs.net/doc/dc12920999.html,="豆浆机"; Product p2=new Product(); https://www.360docs.net/doc/dc12920999.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)数组的元素通过下标来访问,数组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数组的概念和作用

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) 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数组的排序方法实例

冒泡排序法 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数组与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中运用数组的四种排序方法

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中数组的学习完整版一

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基础练习程序 数组冒泡排序

/* 数组排序 */ 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 arr[y+1]){ swap(arr,y,y+1); } } } } //定义数组元素之间位置交换 public static void swap(int[] arr,int index1,int index2){ //定义临时变量 int temp = arr[index1]; arr[index1] = arr[index2]; arr[index2] = temp; } //定义字符串打印 public static String array2string(int[] arr){ String str = ""; for(int x=0;x

java全排列一维数组

全排列一维数组.java 有时候,我们要对一个一维数组进行全排列,这个时候就要用到全排列的算法了,下面是一种全排列的算法.希望对你有用. public class全排列一维数组{ public static void main(String[] args){ String[]A={"1","2","3","4","5","6","7"}; String[][]B=quanpl(A);//创建一个二维数组存放A的全排列;并将数组A的第i种排列存放在二维数组B的第i行中 for(int i=0;i

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)数组的元素通过来访问,数组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]后,下面错误的引用是___ 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]={,,,}; B. int a[][]={{1,2},{3,4}}; 6. C. int a[2][]= {{1,2},{3,4}}; D. float a[2][2]={0}; 7.引用数组元素时,数组下标可以是____ 8. A. 整型常量 B. 整型变量 C. 整型表达式 D. 以上均可 9.定义了int型二维数组a[6][7]后,数组元素a[3][4]前的数组元素个数为____ A. 24 B. 25 C. 18 D. 17 10.下列初始化字符数组的语句中,正确的是____ 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]="";

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 中数组常见的排序问题整理 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标准类库提供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各种数组排序(插入,交换,选择,归类,基数排序)

import java.util.Random; /** * * * 排序算法的分类如下: * 1.插入排序(直接插入排序、折半插入排序、希尔排序); * 2.交换排序(冒泡泡排序、快速排序); * 3.选择排序(直接选择排序、堆排序); * 4.归并排序; * 5.基数排序。 * * 关于排序方法的选择: * (1)若n较小(如n≤50),可采用直接插入或直接选择排序。 * 当记录规模较小时,直接插入排序较好;否则因为直接选择移动的记录数少于直接插人,应选直接选择排序为宜。 * (2)若文件初始状态基本有序(指正序),则应选用直接插人、冒泡或随机的快速排序为宜; * (3)若n较大,则应采用时间复杂度为O(nlgn)的排序方法:快速排序、堆排序或归并排序。 * * */ public class SortTest { /** * 初始化测试数组的方法 * @return 一个初始化好的数组 */ public int[] createArray() { Random random = new Random(); int[] array = new int[10]; for (int i = 0; i < 10; i++) { array[i] = random.nextInt(100) - random.nextInt(100);//生成两个随机数相减,保证生成的数中有负数 }

System.out.println("-----------原始序列-----------------"); printArray(array); return array; } /** * 打印数组中的元素到控制台 * */ public void printArray(int[] source) { for (int i : source) { System.out.print(i + " "); } System.out.println(); } /** * 交换数组中指定的两元素的位置 * * * */ private void swap(int[] source, int x, int y) { int temp = source[x]; source[x] = source[y]; source[y] = temp; } /** * 冒泡排序----交换排序的一种 * 方法:相邻两元素进行比较,如有需要则进行交换,每完成一次循环就将最大元素排在最后(如从小到大排序),下一次循环是将其他的数进行类似操作。 * 性能:比较次数O(n^2),n^2/2;交换次数O(n^2),n^2/4 * * @param source 要排序的数组 * @param sortType 排序类型

相关文档
最新文档