Java学习第十天——数组（遍历）

一 数组的遍历

• 传统for循环
• 增强for循环（each）
• Array类中的ToString方法

1.1传统for循环；依次访问，从第一位元素，访问到最后一位元素

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

System.out.println(i);

}

1.2 增强for循环——for-each循环

for（数据类型 变量名：数组名）{

System.out.println(变量名);

}

int [ ] arr=new int[ n ];

for(int e : arr){

//int e=1; 把arr数组中的元素依次赋值

System.out.println(e);

输出的内容；

1 2 3 4......n

}

特点

a，不需要下标就能获取数组内容

b ，不能给e赋值

c ，不能操作下标

1.3 利用Array类中的toString方法

调用Array.toString(a)，返回一个包含数组元素的字符串，这些元素被放置在括号内，并用逗号分开
 

int[] array = {1,2,3,4,5};
System.out.println(Arrays.toString(array));
输出：[1, 2, 3, 4, 5]

说明：System.out.println(array);这样是不行的，这样打印是的是数组的首地址。

二维数组例；

/**功能；二维数组的遍历
 * @author 宁成伟
 *思路；三种方式
 *	   1，传统for循环
 *	   2，for each循环
 *	   3，Array的ToString方法
 */
public class Demo6 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int [][]a = {
				  {10,21,60},
				  {45,64,123},
				  {78,58,999}
				
		};//创建二维数组
		//1传统for循环遍历输出
		System.out.println("传统for循环遍历输出");
		for(int i=0;i<a.length;i++){
			for(int j=0;j<a[i].length;j++){
				
				System.out.print(a[i][j]+" ");
			}
			System.out.println();
		}
		System.out.println("----------------------------------");
		//2,增强for循环输出
		System.out.println("for ecah循环遍历");
		for(int[] b:a){
			for(int c:b)
			{
				System.out.print(c+" ");
			}
			System.out.println();
		}
		System.out.println("----------------------------------");
		//3.ToString方法遍历
		System.out.println("ToString方法遍历");
		for(int s=0;s<a.length;s++){
			System.out.println(Arrays.toString(a[s]));
		}
		
	}

 

 

 

1.2 数组中的默认值

a 没有数组元素赋值的情况下，依旧可以正确访问数组

int a[ ]=new int [5];

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

System.out.println(a[i]);

}

可以输出，输出结果根据类型不一样，

整数默认为0，

小数默认为0.0

字符默认为\u0000

布尔；false

其他；null

 

 

数组的连续内存空间意义；

数组的引用存在栈例，数据的数据存在堆里，

数组的引用指向的是数据即数组元素的首地址，而后会继续输出相邻接下来的元素。

 

 

 

1.3 数组语句的创建

动态创建数组，创建数组，然后在根据下标一个一个存储数据。

A；先声明，再创建（分配内存空间）

数据类型 [] 数组名

数组名 = new 数据类型 [ 长度]；

B; 声明并创建

数据类型 [ ] 数组名 = new 数组类型[ 长度];

 

1.4 数组的地址转移

了解数组的地址；

int a[ ] = new int (3);

a[0]=1;

a[1]=2;

a[2]=3

System.out,println(a.length); //数组的长度 4

System.out,println(a); //a数组的地址

System.out,println(a[0]); //数组a 第一个元素



int b [ ]={4.5.6.7};

System.out,println(b.length); //4

System.out,println(b); // b的地址

System.out,println(b[0]); //4





int [ ] c=a; //将a的地址指向赋给C,a和c同时指向数组a [ ]的地址

System.out,println(c.length); // 3

System.out,println(c); //a的地址

System.out,println(c[0]); //1





b=c; //c的地址指向并赋给c，b的地址被覆盖，内存空间4,5,6,7丢失，

//c的只有地址，没有开辟内存空间，此时b也只有地址，没有内存空间

c[0] = 100; //此时c的内存空间赋了第一位元素0，并分配地址100，

System.out,println(a.[1]); //100

System.out,println(a.[2]); //100

System.out,println(a.[3]); //100

1.5 数组与方法

a 设计一个方法，原样打印输出被输出的数组

public static void printArray(int [ ] arr){

for(int e : arr){

System.out,println(e);

}

}

 

public static void mian(String args []){

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

printArray(a);

}

 

1.6 数组作为参数

 

b 数组可以作为参数被方法调用,也可以返回数组类型，注意数组被调用与返回值返回时，实际上是一个16进制的堆内存地址被调用与返回：

 

public static String[] getString(String[] arr){

String[] a = new String[];

return a;

}

 

设计一个方法能够生成一个数组，并赋值，返回值数组内容给调用处，

public static int creatArray(){

int [ ] arr= int [10];

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

arr[i] = i * 2;

}

return arr;

}

public static voi main(String args []){

int [ ] b = crreatArray();

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

System.ouy.println(b[i]);

}

}

 

1.6 数组作为返回值

 

 

1.7可变参数

a一个方法可以接受的参数不定（0到多个），但是类型固定。

b,可变参数写在后面 （int a，String s,int ...num）

c,一个方法最多只能接受一个可变参数

 

 

1.8数组的排序

a,冒泡排序；

算法思想：将相邻俩个数进行比较，将较大的数依次往后移，循环每一次得到的他们中的最大值依次存储到最后。(如果数组长度为n，这需要循环n-1次)

[ ] arr = { 15, 23 ,8 , 10, 7};

 

第一轮 15 8 10 7 23

第二轮 0 8 17 15 23

第三轮 8 7 10 15 23

第四轮 7 8 10 15 23

 

 

 

 

注；

1，数组的概念，是存储多个相同数据类型的值的连续的一组内存空间。

2，内存连接 ，数据类型一致，应用类型的数据 。

3,   控制台输入数组；

 

 

引用备注；

引用1；原文链接：https://blog.csdn.net/chenkaibsw/article/details/78989459