赵雅智_java 一维数组

数组：引用数据类型，一组相同类型的数据的有序集合。适用于集中管理类型相同、用途相近的多个数据。

• 相同的数据类型：所有数组元素，可以是基本也可意是引用；
• 数组的长度不可改变：一旦数组的初始化完成，数组在内存中所占的存储空间将被固定下来；
• 访问：通过数组元素的下角

一维数组

• 数组的长度：S数组中的元素个数
• 一维数组的结构：

10个int型数据组成一维数组s

序号	0	1	2	3	4	5	6	7	8	9
元素名	s[0]	s[1]	s[2]	s[3]	s[4]	s[5]	s[6]	s[7]	s[8]	s[9]
元素值	56	67	43	23	32	42	54	22	87	12

• 声明：类型名 变量名[]; 或 类型名[] 变量名;
  • 例如，int[] arr; double salary[]; Student s[];
  • 声明了数组类型变量，运行时系统只为引用变量分配引用空间，并没有创建对象，也不会为数组元素分配空间，因此不能使用任何数组元素。
  • 声明数组类型变量时不允许指定数组的长度： int[3] a; ×
• 创建和使用
  • new 类型名[n]
    例如，int [] arr;
    arr=new int[3];
• 访问：数组名[元素下标]
  • 例如，arr[0]=55; arr[1]=78; arr[2=arr[0]+arr[1];
  • 注意：在访问数组元素时合法的下标范围是0~n-1，如果越界，程序编译时不会报错，但程序运行时会抛越界异常。

    public class Arr
    {
    	public static void main(String[] args) 
    	{
    		int[] arr = new int[3];
    		for(int i=0; i<=3; i++){
    			arr[i]=i;
    			System.out.print("arr["+i+"]="+arr[i]);
    		}
    	}
    }

  • 基本数据类型的一维数组的声明、创建和使用:

    public class Arr 
    {
    	public static void main(String[] args) 
    	{
    		int[] a = new int[5];
    		for(int i =0;i<5;i++){
    			System.out.print(arr[i]+"\t");
    		}
    		System.out.println();
    		for(i=0;i<5;i++){
    			arr[i]=i*i;
    			System.out.print(arr[i]+"\t");
    	}
    }
    

    0 0 0 0 0
    0 1 4 9 16
  • 引用类型的一维数组的声明、创建和使用。

    class Point{
    	private  int x,y;
    	public Point(int x,int y){
    		this.x = x;
    		this.y = y;
    	}
    	public void display(){
    		System.out.print("点的坐标为：（"+x+"，"+y+"）；");
    	}
    }
    public class ArrYinyong
    {
    	public static void main(String[] args) 
    	{
    		Point p[];
    		p = new Point[5];
    		for(int i =0;i<5;i++){
    			p[i] = new Point(i,i+1);
    				p[i].display();
    		}
    	}
    }
    

    点的坐标为：（0，1）；点的坐标为：（1，2）；点的坐标为：（2，3）；点的坐标为：（3，4）；点的坐标为：（4，5）；
• length属性
  • 遍历数组元素时，以只读的方式给出数组的长度，该属性为int类型，可直接访问。
  • 例如，for(int i;i<arr.length;i++) …
  • 注意：Java 语言中数组长度并不属于其数据类型的组成部分。例如，int[] a; a=new int[3]; a=new int[5];
• 静态初始化
  • 基本数据类型
    • int a[]={12，9，36};
      等于int a[] = new int[3];
      a[0] = 12;
      a[1] = 9;
      a[2] = 36;

    • int a[];

      a={12，9，36}; 不对
  • 引用类型数组的静态初始化为：
    Point[] p= { new Point(3,5) , new Point(-4,9) , new Point(2,-9) , new Point(-5,-2) };等于
    Point[] p = {new Point(3,5) ; new Point(-4,9) ; new Point(2,-9) ; new Point(-5,-2) };

排序：

• 获取数组中的最大值

  class  Arr
  {
  	public static int getMax(int[] arr){
  		int max = arr[0];
  		for(int i=1;i<arr.length;i++){
  			if(arr[i]>max){
  				max = arr[i];
  			}
  		}
  		return max;
  	}
  
  	public static void main(String[] args) 
  	{
  		int[] a = {1,4,2,7,6,9,3};
  		int max = getMax(a);
  		System.out.println(max);
  	}
  }
  9

• 选择排序：

  class  Arr2
  {
  	public static void selectSort(int[] arr){
  		for(int i=0;i<arr.length-1;i++){
  			for(int j =i+1;j<arr.length;j++){
  				if(arr[i]>arr[j]){
  					int tem = arr[i];
  					arr[i] = arr[j];
  					arr[j] = tem;
  				}
  			}
  		}
  	}
  	public static void printA(int[] arr){
  		for(int i=0;i<arr.length;i++){
  			System.out.print(arr[i]+"\t");
  		}
  	}
  	public static void main(String[] args) 
  	{
  		int[] a = {1,4,2,7,6,9,3};
  		System.out.println("排序前：");
  		printA(a);
  		selectSort(a);
  		System.out.println();
  		System.out.println("排序后：");
  		printA(a);
  	}
  }
  

• 冒泡排序：

  class  Arr3
  {
  	public static void bubbSort(int[] arr){
  		for(int i=0;i<arr.length;i++){
  			for(int j=0;j<arr.length-i-1;j++){
  				if(arr[j]>arr[j+1]){
  					int tem = arr[j];
  					arr[j] = arr[j+1];
  					arr[j+1] = tem;
  				}
  			}
  		}
  	}
  	public static void printA(int[] arr){
  		for(int i=0;i<arr.length;i++){
  			System.out.print(arr[i]+"\t");
  		}
  	}
  	public static void main(String[] args) 
  	{
  		int[] a = {1,4,2,7,6,9,3};
  		System.out.println("排序前：");
  		printA(a);
  		bubbSort(a);
  		System.out.println();
  		System.out.println("排序后：");
  		printA(a);
  	}
  }