这里主要写一些一维数组的初始化操作与遍历方式，给初学者一些帮助，同时对自己也算是总结吧。
一维数组的初始化分为两种：1、基本类型数组的初始化；2、引用类型数组的初始化；
至于遍历方式也分两种：1、普通的for(){}循环；2、foreach循环；
先说，基本类型数组的初始化，在内部会用这两中遍历方式遍历数组：
package com.google.array.array01;
/**
* 基本类型数组：数组中的元素是基本类型的数据，这种数组就成为基本类型的数组：
* 有8种：byte,short,int,long,float,double,char,boolean
*/
public class BaseTypeArray {
public static void main(String[] args){
//先定义一个数组：arr[0]=1,arr[1]=8,arr[2]=4,arr[3]=3,arr[4]=25,arr[5]=47,arr[6]=45,
int[] arr={1,8,4,3,25,47,45};
//使用for循环遍历数组：1,8,4,3,25,47,45,
circulation01(arr);
//使用foreach循环遍历数组：
circulation02(arr);
}
/**
* 数组的定义:用两种方式
* 这里使用int类型
*/
public static void defineArray(){
int[] arr;
int arr02[];
}
/**
* 数组的赋值：3种
*/
public static void initArray(){
//第一种赋值方式：
int[] arr = new int[3];
arr[0]=0;
arr[1]=1;
arr[2]=2;
//第二种赋值方式：
int[] arr02 = new int[]{0,1,2};
//第三种赋值方式：
int[] arr03={0,1,2};
}
/**
* for循环遍历数组
* @param arr
*/
public static void circulation01(int[] arr){
for(int i=0;i<arr.length;i++){
System.out.print("arr["+i+"]="+arr[i]+",");
}
}
/**
* foreach遍历数组
* @param arr
*/
public static void circulation02(int[] arr){
for(int a:arr){
System.out.print(a+",");
}
}
}
再说引用类型的数组，同样用for和foreach遍历：
先定义一个实体类：
package com.google.array.array02;
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
然后在对这个引用类型的实体类进行操作：
package com.google.array.array02;
/**
* 引用类型数组的引用：
*/
public class RefTypeArray {
public static void main(String[] args){
/**
* student[0]=Student{name='张1', age=1}
name-0=张1
age-0=1
student[1]=Student{name='张2', age=2}
name-1=张2
age-1=2
student[2]=Student{name='张3', age=3}
name-2=张3
age-2=3
*/
dynamicInit();
/**
* Student{name='赵6', age=12}
Student{name='赵7', age=15}
Student{name='赵8', age=17}
*/
staticInt();
}
/**
* 动态初始化引用类型的数组：
*/
public static void dynamicInit(){
//创建学生对象：
Student stu1=new Student("张1",1);
Student stu2=new Student("张2",2);
Student stu3=new Student("张3",3);
//创建一个数组容器，尺寸为3，用来存放学生元素：
Student[] student=new Student[3];
student[0]=stu1;
student[1]=stu2;
student[2]=stu3;
print1(student);
}
/**
* 静态初始化数组：
*/
public static void staticInt(){
//第一种方式：
Student[] student={new Student("赵6",12),new Student("赵7",15),new Student("赵8",17)};
//第二种方式：有点麻烦
/*Student stu1=new Student("赵6",12);
Student stu2=new Student("赵7",15);
Student stu3=new Student("赵8",17);
Student[] student2={stu1,stu2,stu3};*/
print2(student);
}
/**
* 采用for循环：
* @param student
*/
public static void print1(Student[] student){
for(int i=0;i<student.length;i++){
System.out.println("student["+i+"]="+student[i]);
System.out.println("name-"+i+"="+student[i].getName());
System.out.println("age-"+i+"="+student[i].getAge());
}
}
/**
* 采用foreach循环：
* @param student
*/
public static void print2(Student[] student){
for(Student stu:student){
System.out.println(stu);
}
}
}
至于内存分析，这里就不说了，只要记住，数组是一个引用，
对于基本类型，内部存放的是数值；
对于引用类型，内部存放的仍然是一个引用；