Java数组之一维数组

##数组声明
###语法格式
数据类型[] 数组名;
数组类型 数组名[];
例:
```java
int[] myIntArray;
int myIntArray[];
char[] ch;
String [] strArray;
```
###数组创建
####语法格式一：先声明后创建
数据类型[] 数组名;
数组名 = new 数据类型[数组长度];
例：
```java
int[] arr;
arr = new int[10];
```
创建了一个长度为10的整型数组
####语法格式二：声明的同时创建数组
数据类型[] 数组名 = new 数据类型[数组长度];
```java
int[] arr = new int[10];
```
创建长度为10的整型数组arr
注意：数组长度必须指定
###数组在内存中的存储
数组会被分配连续的内存空间
###数组的初始化
1.声明数组的同时给数组赋值，叫做数组的初始化
例：
```java
int[] arr = {1,2,3,4,5,6,7,8,9,10};
//数组的长度就是初始化时所给数组元素的个数
```
###数组元素的引用
1.语法格式：
数组名[下标];
注意：下标从0开始

2.数组长度
```java
int[] a = {1,2,3,4,5,6,7,8,9,10};
```
属性length表示数组的长度，如a.length
```java
int[] intArray; 				//声明一个整型数组

String strArray[];				//声明一个字符串类型的数组

intArray=new int[5];

strArray=new String[10];		//创建数组

float[] floatArray=new float[4];  //声明数组的同时进行创建

char[] ch={'a','b','c','d'};		//初始化数组

System.out.println("ch数组的长度为："+ch.length);

System.out.println("intArray数组的第2个元素为："+intArray[1]);

System.out.println("strArray数组的第5个元素为："+strArray[4]);

System.out.println("floatArray数组的最后一个元素为："+floatArray[floatArray.length-1]);
//循环为整型数组赋值
for(int i=0;i<5;i++){
    intArray[i]=i+1;
}
//循环输出整型数组中的元素
System.out.println("整型数组intArray的元素为：");
for(int i=0;i<5;i++){
    System.out.print(intArray[i]+"	");
}
```
整型数组的默认值为0；

字符串类型数组的默认值为null；

浮点型数组的默认值为0.0；
```java
package imoocProj;

import java.util.Scanner;

public class ArrayDemo {

public static void main(String[] args) {
	// 求整型数组的累加和
	//定义整型数组
	int[] a=new int[5];
	Scanner sc=new Scanner(System.in);
	//从键盘接收数据，为数组元素赋值
	for(int i=0;i<a.length;i++) {
		System.out.println("请输入第"+(i+1)+"个元素：");
		a[i]=sc.nextInt();
	}
	System.out.println("数组元素的内容为:");
	for(int i=0;i<a.length;i++) {
		System.out.println(a[i]+"	");
	}
	//求数组累加和
	int sum=0;
	for(int i=0;i<a.length;i++) {
		sum=sum+a[i];
	}
	System.out.println();
	System.out.println("数组元素的累加和为："+sum);

}

}
```
###编程练习

求数组中能被3整除的元素并打印输出。效果如下：
```java
能被3整除的数组元素为:
3
6
9
12
15
```
```java
public class ArrayDemo {
    public static void main(String[] args) {
		int[] intArray=new int[15];//定义一个整型数组，并初始化
		for(int i=0;i<intArray.length;i++){
		    intArray[i]=i+1;
		}
		
	System.out.println("能被3整除的数组元素为:");
	for(int i=0;i<intArray.length;i++){
	    if(intArray[i]%3==0){
	        System.out.println(+intArray[i]);
	    }
	}
	
	//循环遍历数组，找出能被3整除的元素并打印输出
	
}

}
```
```java
package imoocProj;

public class ArrayDemo1 {

public static void main(String[] args) {
	// 求数组元素的最大值
	int[] a= {34,23,78,56,31};
	int max=a[0];
	for(int i=1;i<a.length;i++) {
		if(max<a[i]) {
			max=a[i];
		}
	}

}

}
```
###增强型for循环

又称foreach循环

foreach循环应用：
```java
int[] arr={1,2,3,4,5};
for(int n:arr)
	System.out.println(n);
```
###冒泡排序

对一组整数按从小到大的顺序排列
```java
package imoocProj;

public class SortDemo {

public static void main(String[] args) {
	// 冒泡排序
	int[] a= {34,53,12,32,56,17};
	System.out.println("排序前的数组元素为:");
	for(int n:a) {
		System.out.print(n+"   ");
	}
	System.out.println();
	int temp;
	for(int i=0;i<a.length-1;i++) {
		//内重循环控制每趟排序
		for(int j=0;j<a.length-i-1;j++) {
			if(a[j]>a[j+1]) {
				temp=a[j];
				a[j]=a[j+1];
				a[j+1]=temp;
			}
		}
	}
	System.out.println("从小到大排序后的数组元素为:");
	for(int n:a) {
		System.out.print(n+"   ");
	}
}

}
```
排序前的数组元素为:
34   53   12   32   56   17   
从小到大排序后的数组元素为:
12   17   32   34   53   56

###编程练习2

定义一个字符数组并初始化，统计字符’a’或’A’出现的次数(结果：字符数组中字符'a'或'A'的个数为：4)
```java
public class ArrayDemo {
    public static void main(String[] args) {
		char[] ch={'a','A','b','c','a','A','r','t','i','q'};
		int count=0;
		for(int i=0;i<ch.length;i++){			//循环遍历数组，统计字符’a’或’A’出现的次数
		    if((ch[i]=='a')|(ch[i]=='A')){
		        count++;
		    }
		}
		System.out.println("字符数组中字符'a'或'A'的个数为："+count);	//打印输出统计数据
	
}

}
```