Java基础知识回顾-数组

最新推荐文章于 2022-10-13 05:06:57 发布
最新推荐文章于 2022-10-13 05:06:57 发布
阅读量222 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wo6218298/article/details/98171669
版权

数组简介：
我之前已经接触过数组了,就是主函数(main方法)中的参数:
public static void main(String[] args){

}
存放同一种数据类型的容器
数组是指一组数据的集合，数组中的每个数据称为元素。在Java中，数组也是Java对象。数组中的元素可以是任意类型(包括基本类型和引用类),但同一个数组里只能存放类型相同的元素。

-----数组的创建和使用：
创建数组大致包括如下步骤：
 声明一个数组类型的引用变量，简称为数组变量；
 用new语句构造数组的实例。new语句为数组分配内存，并且为数组中的每个元素赋予默认值；
 初始化，即为数组的每个元素设置合适的初始值。

一. 数组变量的声明:
 基本数据类型数组：int [ ] Array || int Array [ ] 数组中存放的是基本数据类型。
 类类型数组： Teacher [ ] Array 或者 Teacher Array [ ]数组中存放的是Teacher类创建的若干个的对象。
推荐使用第一种写法。c#只有第一种写法

声明数组：
1) 一个存放同一类型数据的集合
a. 即可以是基本类型，也可以是对象类型；
b. 数组中的每个数据为元素；
2) 数组是一个对象，成员是数组长度和数组中的元素;
3) 声明了一个数组变量并不是创建了一个对象;
注意：声明数组变量的时侯，不能指定数组的长度，以下声明方式是非法的。

 int x[1]  ||  int[2] x;

二. 初始化
初始化：自变量创建后首次赋值的过程；
1. 创建数组对象:
数组对象和其他Java对象一样，也用new语句创建；
int [ ] Array = new int [2];

   new int [2]语句执行以下步骤：

 在堆区中为数组分配内存空间，以上代码创建了一个包含2个元素的int数组
 为数组中的每个元素赋予其数据类型的默认值。
 byte/short/int/long 0
 float 0.0f
 double 0.0d
 String null
 char ‘\u0000’
 boolean false
 返回数组对象的引用

注意：在用new语句创建数组对象时，需要指定数组长度。数组长度表示数组中包含的元素数目。数组长度可以用具体的数值表示，也可以用变量表示。如：
 int[ ] x = new int[10];
 int size=10;
int[] x = new int[size];

数组的长度可以为0，此时数组中一个元素也没有。例如：
int[] x = new int[0];

对于Java类的程序入口方法main(String args[]),如果运行时这个类没有输入参数，那么main()方法的参数args并不是null, 而是一个长度为0的数组。例如：

 public class Sample {
       public static void main(String[] args) {
              System.out.println(args.length);           //打印0
       }
 }

数组对象创建后，它的长度是固定的。数组对象的长度是无法改变的，但是数组变量可以改变所引用的数组对象。

   int[ ]  x = new int[3];
   int[ ]  y = new int[4];
   x=y;
   x = new int[4];
  1. 初始化数组对象:
    数组中的每个元素都有一个索引，或者称为下标。数组中的第一个元素的索引为0，第二个元素的索引为1, 依次类推。
    通过索引可以访问数组中的元素或者给数组中元素内容赋值。
  1. 声明、创建、初始化分开：
	 //声明
    int[ ]  iArray;
    //创建
    iArray = new int[2];
	 //初始化
    iArray[0] = 0;
    iArray[1] = 1;
  1. 声明、创建的同时并初始化数组:
int[] b = {1,2,3,4,5}; 			//只是省略new int[] ，与下边相同
int[] b = new int[]{1,2,3,4,5};

 int[ ] iArray = {0, 1};
 int[ ] iArray = new int[ 3];动态初始化（初始化时只指定数组长度，由系统为数组分配初始值）
 int[ ] iArray = new int[ ]{0, 1}; 静态初始化（初始化时指定每个数组元素的初始值）
 Student[ ] sArray= new Student[ ] { new Student(“George”, “Male”, 20), new Student()};
 Student[ ] stArray = { new Student(), new Student()} ;

注意：a.下面这些都是非法的数组初始化方式：

（1） int[ ]  x = new int[5] {5,4,3,2,1};

//编译出错，创建数组对象的同时并初始化的时候就不能指定数组长度了；
               
（2）int[ ]  x;
     x = {5,4,3,2,1};                           
//{5,4,3,2,1}必须在声明数组变量的语句中使用，不能单独使用

问与答：1) 求一组值的平均值：

    public class ArrayAvgTest {
    public static void main(String[] args) {
                ArrayAvgTest a = new ArrayAvgTest();
                int[] a = {100,60,80,90,75,38};
                System.out.println("Avg score: " + a.avg(a));
           }
           public double avg(int[] n) {
               double result = 0.0;
               for(int i=0;i<n.length;i++) {
                    result += n[i];
                }
                result /= n.length;         
                return result;
           }
     }

多维数组

Java支持多维数组。

String[][] s = new String[3][];         3必须指定
String[][] s = new String[3][4];   

String [ ][ ]  arr = {   { {},{} },{ {},{} },{ {},{} }   } ;

假定某个宾馆有三层楼，第一层有4个房间，第二层有3个房间，第三层有5个房间。某一天客户人住宿情况如下图所示:
第三层: | | Tom | Jerry | | Rose |
第二层： | Mary | | Kevin |
第一层： | Mike | Jane | Duke | |

可以用两维数组来存储各个房间的客人信息。

       String[ ][ ] room = new String[3][ ];
       room[0] = new Stirng[]{"Mike","Jane","Duke",null};
       room[1] = new String[]{"Mary",null,"kevin"};
       room[2] = new String[]{null,"Tom","Jerry",null,"Rose"}
以上代码等价于:
       String[ ] [ ] room = {
{"Mike","Jane","Duke",null},{"Mary",null,"kevin"},{null,"Tom","Jerry",null,"Rose"}
 };

多维数组本质上是数组的数组，数组的元素内容还是数组；

写一个类MultiArray.java来创造一个二维数组并输出其中元素

package com.briup.day07;
public class MultiArray {
	public static void main(String[] args){
			//第一种创建
			/*
			String[][] student = new String[3][] ;
			student[0] = new String[]{"Ad","Bd","Cd"};
			student[1] = new String[]{"Ed","Dd","Fd"} ;
			student[2] = new String[]{"Gd","Hd","Jd"};
			*/
			//String[ ][ ] student = {{"Ac","Bw","Cd"},{"Ef","Ds","Fd"},{"Gd","Hd","Jd"}};	
		String[ ][ ] student=newString[ ][ ]{{"Ad","Bd","Cd"},{"Ed","Dd","Fd"},{"Gd","Hd","Jd"}};
			for(int i=0;i<student.length;i++){
				for(int k=0;k<student[i].length;k++)
				{
					System.out.print("\t"+student[i][k]);
				}
				System.out.println();
			}		
	 }
}

数组的边界

  1. 一个数组的下标从0开始，数组通过数组的对象引用变量的下标访问数组。
    数组中第一个元素的索引为0, 第二元素的索引为1，依次类推。如果一个数组长度是5，要访问最后一个数组元素可以通过下标4来访问，如果通过下标5访问，超出了数组的边界，在运行时会抛出ArrayIndexOutOfBoundsException。

  2. 通过调用数组的length方法可以获得一个数组的元素个数（数组长度）。
    所有Java数组都有一个length属性，表示数组的长度. 该属性只能读取，但是不能修改。
    以下修改数组的length属性，这是非法的。

          int[] x = new int[4];
          x.length = 10;            //编译出错，length属性不能被修改。

注：a. 数组变量必须在指向一个数组对象之后，才能访问其元素。
b. 当数组的元素为引用类型时，数组中存放的是对象的引用，而不是对象本身；
Q2.求一组值的最大值：

    public class ArrayMaxTest {
  		  public static void main(String[] args) {
                ArrayMaxTest a = new ArrayMaxTest();
                int[] n = {100,60,80,90,75,38};
                System.out.println("Max score: " + a.max(n));
          }
          public int max(int[] n) {
                int result = n[0];
                for(int i=1;i<n.length;i++) {
                    if(result<n[i])
                       result = n[i];
                }
                return result;
          }
     }

数组内容排序
冒泡排序：值较小的数逐渐向数组的顶部(即朝第一个元素)冒上来，就像水中的气泡上升一样，同时，值较大的数据逐渐向数组的底部(即朝最后一个元素)沉下去。这种算法用嵌套的循环对整个数组进行数次遍历，每次遍历都要比较数组中相邻的一对元素，如果这对元素以升序(或者值相等)的顺序排列，那么保持它们的位置不变；如果这对元素以降序的顺序排列，那么交换它们的值。

Q3.对下边数组进行冒泡排序
数组原内容：100,60,80,90,75,38
第一次循环： 60 80 90 75 38 100
第二次循环： 60 80 75 38 90 100
第三次循环： 60 75 38 80 90 100
第四次循环： 60 38 75 80 90 100
第五次循环： 38 60 75 80 90 100

public class ArraySortTest {
public static void main(String[] args) {
		ArraySortTest s = new ArraySortTest();
		int[] n = {100,60,80,90,75,38};
		s.sort(n);
		s.print(n);
 }
public void sort(int[] n) {
	  for(int i=0;i<n.length-1;i++) {
		 for(int j=0;j<n.length-i-1;j++) {
				if(n[j]>n[j+1]) {
						int temp = n[j];
						n[j] = n[j+1];
						n[j+1] = temp;
				}
			}
			print(n);
		}
}

public void print(int[] n) {
		for(int i=0;i<n.length;i++)
				System.out.print(n[i] + "\t");
				System.out.println();
	 }
}

第二种：

package com.briup.day07;
//冒泡排序
public class ArraySortTest{
	public static void main(String[] args){
		int[] arr = new int[]{100,60,80,90,75,38};
		
		for(int i=0;i<arr.length-1;i++){
			for(int j=0;j<arr.length-1-i;j++){
				if(arr[ j ]>arr[ j+1 ]){
					arr[j]=(arr[j]+arr[j+1])-(arr[j+1]=arr[j]);
					/*
					int temp = arr[ j ];
					arr[j]=arr[j+1];
					arr[j+1]=temp;					
					*/
				}
			}
		}
		for(int k=0;k<arr.length;k++){
			System.out.println(arr[k]);
		}
	}	
}

选择排序:
在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。

Selection.java
package com.briup.day07;
public class Selection {
	public static void main(String[] args){
		int[] a = {12,32,3,21,5};
		for(int i=0;i<a.length-1;i++){
			int p = i;   //与循环趟次有关
			for(int j=i+1;j<a.length;j++){
				if(a[p]>a[j]){
					p=j;
				}
			}
			int temp = a[i];
			a[i] = a[p];
			a[p] = temp;
		}
		for(int i=0;i<a.length;i++){
			System.out.println(a[i]);
		}
	}
}

java.util.Arrays辅助类的使用。sort(int[ ] n)

import java.util.Arrays;
public class SortTest{
	public static void main(String[] args){
		int [ ] arr = {12,21,24,6,2};
		for(int i=0;i<arr.length;i++){
			System.out.print(arr[i]+" ");
		}
		System.out.println();
		Arrays.sort(arr);
		for(int i=0;i<arr.length;i++){
			System.out.print(arr[i]+" ");
		}
	}
}

Q5. 从众多手机号码中抽取一个获奖手机号码

public class ArrayRandomTest {
	 public static void main(String[] args) {
		 ArrayRandomTest a = new ArrayRandomTest();				 
	   	 String[]n={"1318259016","13564560540","13858687810","13999999999"};
		 System.out.println(a.getTel(n));
	 }
	 public String getTel(String[] n) {
		    int index = (int)(Math.random()*n.length);  //产生随机数
			return n[index];
	 }
}

Q6.产生四位长度的验证码, 验证码内容为大小写字母或数字组成；

package com.briup.day07;
public class ArrayValidateCodeTest {
	private char[] c;
	public static void main(String[] args) {
		ArrayValidateCodeTest a = new ArrayValidateCodeTest();
		System.out.println(a.getValidateCode());
	}
	//构造
	public ArrayValidateCodeTest() {
		String s = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
	    c = s.toCharArray();
	}
	//生成随机数
	public String getValidateCode() {
		int i1 = (int)(Math.random()*c.length);
		int i2 = (int)(Math.random()*c.length);
		int i3 = (int)(Math.random()*c.length);
		int i4 = (int)(Math.random()*c.length);
		return ""+c[i1]+c[i2]+c[i3]+c[i4];     //""将int类转换为字符串类
	}		
}

———数组的拷贝 arraycoppy()

数组的长度一旦确定之后便不能调整，我们可以通过复制数组的内容变通实现改变数组长度。在System类中提供一个辅助的arraycopy方法提供复制数组内容的功能: java.lang包中不需要导包
public static void arraycopy
(Object src , int srcPos , Object dest , int destPos , int length)
参数1,需要被复制的目标数组
参数2,从这个数组的那个一个位置开始复制
参数3,需要把数据复制到的另外的那一个新的数组对象
参数4,复制到新数组里面哪个位置(从这个位置开始算)
参数5,复制的目标数组的长度

ArrayCopy.java
package com.briup.day07;
public class ArrayCopy{
	public static void main(String[] args){
		int[] a = new int[]{1,2,3,4,5};
		int[] b = new int[a.length*2];
		System.arraycopy(a,0,b,0,5);   //java.lang包中
		a=b;                         //改变数组a的长度
		System.out.println(a.length);
		for(int i=0;i<b.length;i++){
			System.out.println(b[i]);      
		}
	}
}

可变长参数 JDK1.5或以上
之前的写法：

public static void main (String args[]){
	    int[] i = {1,2,3,4};
	    a.test(i);
}
public void test(int[ ] a){
	
}

可变参数写法：

    public static void main (String args[]){
     int[] i = {1,2,3,4};
    	    a.test2(i);             //传入数组
    	    a.test2();              
    	    a.test2(1,2,3,4);
    	    a.test2(1,2,3,4,5,6,7);
    }
    public void test2(int... a){
    	
    }

可变参数前面可以加其他参数

public static void main (String args[]){
	    int[] i = {1,2,3,4};
	    String msg = "helo";
	    a.test3(msg,i);
	    a.test3(msg);
	    a.test3(msg,1,2,3,4);
	    a.test3(msg,1,2,3,4,5,6,7);
}
public static void test3(String msg,int... a){
	
}

可变参数后面不能加任何参数 这样是编译不通过的:错误
/不定长参数必须放在参数列表的最后位置，有且只能有一个,无论什么类型

public static void test4(int... a,String msg){
	
}

For-Each循环也叫增强for循环

int[] arr={1,2,3,4,5};
for(int i:arr){
	System.ou.println(i);
}

丢失了索引信息

无畏东西
关注
专栏目录
Java基础--数组练习2
人生得意须尽欢
07-25 645
Java基础之数组练习第二弹！！！
Java基础--数组的认识（通透！！！）
人生得意须尽欢
07-22 539
狂肝一天，通透至极，万字长文！！！ 初学Java的小白看过来，教会你Java数组入门！！！ 保证你对数组有焕然一新的感觉！！！
学习java使用数组编写学生管理系统
old_tumour的博客
05-25 5729
我学习了数组的使用。数组可以把一些相同类型的元素储存起来，并且很容易读取。利用数组，我们就可以制作一个简单的学生管理系统，可以记录学生的姓名，年龄，成绩。 数组的长度是不变的，必须一开始就定义好。但是我发现java的数组和c语言的数组在建立的时候有所不同。C语言的数组在建立时，只能用常理定义数组的长度，而不能使用变量，否则编译器就会报错。但是java不一样，java可以使用变量定义数组的长度。所
java基础：数组
lalala_dxf的博客
02-17 3563
数组 二维数组
Java复习
qi_qi14的博客
06-08 4497
Java中的switch-case分支结构中，一旦控制表达式的计算结果与某个case值匹配成功，就执行完该case对应的语句块，即结束switch-case语句。（ F ） 使用break语句可以跳出一次循环。（ F ） Java中continue语句的作用是结束本次循环，开始下一次循环。（ T ） Java中数组的元素只能是简单数据类型。（ F ） 数组作为方法的参数时，必须加在数组名后加方括号。（ T ） 数组中有length()这个方法，如array.length()表示数组arra
java中的多维数组的简介说明
qq_25073223的博客
10-13 306
java中的多维数组的简介说明
再见了SpringMVC！这个框架有点厉害，甚至干掉了Servlet！
程序员白楠楠的博客
09-20 502
# 前言 对 Java 开发者来说， Spring 发布 5.0 正式版，而新版 Spring 的一大特色，就是 Reactive Web 方案 Web Flux，这是用来替代 Spring Web MVC 的吗？或者，只是终于可以不再基于 Servlet 容器了？ # 基于 Servlet 容器的 Web MVC 身为 Java 开发者，对于 Spring 框架并不陌生。它起源于 2002 年、Rod Johnson 著作《Expert One-on-One J2EE Design and Develop
Java基础--Java数组的认识（通透！！！）
07-23
Java数组的认识是Java基础知识中的一部分，了解Java数组的概念、性质、写法、初始化、元素访问和应用是非常重要的。本节课程将带您深入了解Java数组的世界。 一、 简单回顾 在学习Java之前，我们需要了解基本的...
Java基础--数组练习2：互换元素案例与创建两个数组案例
Java基础--数组练习2 在Java中，数组是一种用来存储一组相同数据类型的数据的容器。它的特点包括数组是一个引用数据类型，数组内部可以存储基本类型或引用类型的元素。当我们创建数组时，需要指定数组的长度，并在...
Java程序设计课程实验4-数组
最新发布
12-14
Java程序设计课程实验4主要关注的是数组这一核心概念，它在编程中扮演着基础且重要的角色。数组是一种数据结构，可以存储同类型的多个元素。在Java中，数组提供了高效访问和管理一组数据的方式。 (一) 实验目的： 1...
为什么Java数组长度不可改变？
木申的博客
08-22 9450
数组的内存是连续分配的； int [] array = {1, 2 ,3}; 假设数组内存如上图所示，那么当我们增加数组长度时，就可能导致别的变量被覆盖，导致出错。 这时，有人会想，那减少长度也是可以的呀，但是这会出现一个现象，那就是突然，空出来一个内存空间。 如果内存空间一开始就分配好，那么会符合整体布局，这个空间可以和别的空间组合，变成一块更大的空间。 如下图所示： 综合上...
java改变数组长度_Java修改数组长度
weixin_28622215的博客
02-12 3198
java中没有关于修改数组长度的api,在此本人提供了修改数组长度的两个函数:arrayAddLength()和arrayReduceLength().详细见代码.[java] view plaincopyprint?import java.lang.reflect.Array;/*** Description: This class is used to adjust array length....
java修改数组长度/大小
牛儿吃草的博客
01-22 2万+
java中没有关于修改数组长度的api,在此本人提供了修改数组长度的两个函数:arrayAddLength()和arrayReduceLength().详细见代码. import java.lang.reflect.Array; /** * Description: This class is used to adjust array length. * @author e421083
在Java中调整数组长度
weixuan_的博客
05-24 2083
在Java中调整数组长度
Java实现长度可变数组
热门推荐
404NOTFound
05-13 2万+
1、数组：数组是一种数据结构，用来储存同一种类型值得集合，数组一旦被创建就不能改变它的大小。2、既然数组的长度是不可改变的，那么怎么实现长度可变呢？思路：既然数组长度不可变，那么我们可以创建一个长度与原数组不同的新数组，让原数组变量指向新数组，从而实现长度可变（新数组如果没有使用，那么就会被java垃圾回收机制回收销毁，从而不浪费内存空间。）a)直接创建新数组，让原数组变量指向新数组。代码如下：i...
JAVA实现动态调整数组的大小
灿夏
07-12 1万+
import io.netty.util.internal.ReadOnlyIterator; import org.hibernate.loader.custom.Return; import java.util.Iterator; /** * 《算法》第四版 动态调整数组大小 * * @author 灿夏Summer * @@date 2018-07-12 */ public cl...
Java的数组长度为什么不能改变？
陈小哥cw
03-04 5889
Java中的数组是定长的！你这样int[] a ={}; 定义出来的数组a 长度为0，已经是定长了，之后再给它赋值是不可以的，因为它的长度定义出来之后是不可改变的了。所以在使用数组的时候，一定要注意长度，不能超过这个长度，负责就数组下表越界了。 如下代码: public class ddd { public static void main(String[] args){ ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值