黑马程序员——java数组

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

1.       数组的定义

概念：同一类型数据的集合，其实数组就是一个容器

数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素

 格式：

           ①元素类型[] 数组名 = new 元素类型[元素个数或数组长度]

            示例：int[] arr = new int[5];

           ②元素类型[] 数组名 = new 元素类型[] {元素,元素,……};

              int[] arr =new int[]{2,5,1,7};

                    int[] arr = {2,5,1,7};

2.       内存结构

           java程序在运行时，需要在内存中分配空间。为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存处理方式。

栈：自动释放  堆：垃圾回收

         ■栈内存

        用于存储局部变量，当数据使用完，所占空间会自动释放

    ■堆内存

        数组和对象，通过new建立的实例都存放在堆内存中

        每一个实体都有内存地址只值

        实体中的变量都有默认初始值

        实体不在被使用，会在不确定的时间内被垃圾回收器回收

    ■方法区

         ■本地方法区

     ■寄存器

           异常：ArrayIndexOutOfBoundsException   数组角标越界

                      NullPointerException   空指针异常

           数组中有一个属性可以直接获取到数组元素个数。length

           使用方式：数组名称.length=

           获取数组中的元素，通常会用到遍历

3.       排序

获取最值

/*获取最大值*/
public class Array1 {
	public static void main(String[] args) {
		int[] arr = {5,1,6,4,2,8,9};
		int y[][];
		int max = getMax2(arr);
		System.out.println(max);
	}
	//获取最大值
	private static int getMax1(int[] arr) {
		int max=arr[0];
		for (int i = 0; i < arr.length; i++) {
			if(arr[i]>max){
				max=arr[i];
			}
		}
		return max;
	}
	//利用角标获取最大值
	private static int getMax2(int[] arr){
		int max=0;
		for (int i = 1; i < arr.length; i++) {
			if(arr[i]>arr[max]){
				max=i;
			}
		}
		return arr[max];
	}
}

/*数组排序*/
public class Array2 {
	public static void main(String[] args) {
		int[] arr = {7,4,10,2,9,5,6};
		int[] arr2 = {7,4,10,2,9,5,6};
		selectSort(arr);
		printArray(arr);
		System.out.println();
		bubbleSort(arr2);
		printArray(arr2);
	}
	//选择排序
	private 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]){
					arr[i]=arr[i]^arr[j];
					arr[j]=arr[i]^arr[j];
					arr[i]=arr[i]^arr[j];
				}
			}
		}
	}
	//冒泡排序
	private static void bubbleSort(int[] arr){
		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]^arr[j+1];
					arr[j]=arr[j]^arr[j+1];
				}
			}
		}
	}
	//输出数组
	private static void printArray(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			if(i!=arr.length-1){
				System.out.print(arr[i]+",");
			}else{
				System.out.print(arr[i]);	
			}
		}
	}
}

                    Arrays.sort(arr);

折半查找

/*折半查找*/
public class Array3 {
	public static void main(String[] args) {
		int[] arr = { 1, 2, 3, 4, 5, 6, 7,8, 9, 10, 11, 12, 13 };// 8
		System.out.println(halfSearch3(arr, 8));

	}
	//折半法查找一个数（存在或不存在）在数组中的应该插入位置
	public static int halfSearch3(int[] arr, int key) {
		int min = 0, max = arr.length - 1, mid;
		while (min <= max) {
			mid = (max + min) >> 1;
			if (arr[mid] > key) {
				max = mid - 1;
			} else if (arr[mid] < key) {
				min = mid + 1;
			} else {
				return mid;
			}
		}
		return min;
	}
	//折半法查找2
	public static int halfSearch2(int[] arr, int key) {
		int min = 0, max = arr.length - 1, mid;
		while (min <= max) {
			mid = (max + min) >> 1;
			if (arr[mid] > key) {
				max = mid - 1;
			} else if (arr[mid] < key) {
				min = mid + 1;
			} else {
				return mid;
			}
		}
		return -1;

	}
	//折半法查找1
	public static int halfSearch(int[] arr, int key) {
		int min, max, mid;
		min = 0;
		max = arr.length - 1;
		mid = (min + max) / 2;
		while (arr[mid] != key) {
			if (arr[mid] > key) {
				max = mid - 1;
			} else if (arr[mid] < key) {
				min = mid + 1;
			}
			if (max < min)
				return -1;
			mid = (max + min) / 2;
		}
		return mid;
	}
	//获取查找数据在数组中的脚标
	public static int getIndex(int[] arr, int key) {
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] == key) {
				return key;
			}
		}
		return -1;
	}
}

4.       进制转换

查表法

public class Array4 {
	public static void main(String[] args) {
		// toBin(6);
		trans(6,2);
	}
	//查表法
	public static void trans(int num,int base){
		char[] chars = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A',
				'B', 'C', 'D', 'E', 'F' };
		char[] arr = new char[8];
		int pos=arr.length;
		int offset = 0;
		if(num==0){
			System.out.println(0);
			return;
		}
		switch (base) {
		case 2:
			System.out.print("转为2进制：");
			offset=1;
			break;
		case 8:
			System.out.print("转为8进制：");
			offset=3;
			break;
		case 16:
			System.out.print("转为16进制：");
			offset=4;
			break;
		default:
			System.out.println("转换错误！");
			break;
		}
		
		while(num!=0){
			arr[--pos]=chars[num%base];
			num=num>>>offset;
		}
		for (int i = pos; i < arr.length; i++) {
			System.out.print(arr[i]);
		}	
	}
}

5.       数组中的数组

二维数组[][]

格式：

1.       int[][] arr = new int[3][2]

★定义了名称为arr的二维数组

★二维数组中有3个一维数组

★每一个一维数组中有2个元素

★一维数组的名称分别为arr[0],arr[1],arr[2]

★给第一个一维数组1脚标位赋值为78写法是：arr[0][1]=78

2.  int[][] arr = new int[3][]

★二维数组中有3个一维数组

★每一个一维数组都是默认初始值null

★可以对这三个一维数组分别进行初始化

    arr[0] = new int[3];

    arr[1] = new int[3];

    arr[2] = new int[3];

int[] x---int x[]

int[][]y---int[] y[]---inty[][]

int[] x,y[]---int[]x;int[][]y