黑马程序员_Java基础_04数组

一.数组的声明、创建、初始化

        一维数组的声明方式：
                type[] var;
                type var[];
                声明数组不能指定其长度（数组元素的个数）
       Java中使用关键字new创建数组对象，格式为：
       arrayName = new type[数组元素个数]；
    初始化：
       1.动态初始化：数组定义与分配空间和赋值操作分开进行；
       2.静态初始化：在定义数组的同时就为数组元素分配空间并赋值；
       3.默认初始化：数组是引用类型，它的元素相当于类的成员变量，因此数组分配空间后每个元素也按照成员变量的规则被隐士初始化。
二.打印数组长度和数组元素
        打印数组元素:for循环和for each循环
        打印数组长度:数组名称.length；
三.数组拷贝：
       1.java.util.Arrays.copyOf(Object src,int lengthlength)
               src代表源数组；length代表拷贝的元素个数，从第角标为零的元素开始复制；该方法的返回类型为和源数组同类型的数组
      2.java.lang.System.arraycopy(Object src,int srcPos,Object dest,int destPos,length);
                Object代表源数组，srcPos代表从源数组的第几个元素开始拷贝，dest代表目标数组，destPos代
       表从源数组拷贝的元素从目标数组的第几个元素位置开始存放，length表示从源数组拷贝的元素个数
四.数组元素排序：
        1.选择排序：第一轮，用数组的第一个元素和其余元素比较，如果其它元素比第一个元素小则互换位置，直到一轮结束，最小的元素排在第一位；第二轮从第二个元素开始  重复之前的动作，直到一轮结束取出次小的元素放在第二个元素的位置；重复操作，直到数组元素顺序排列

    2.冒泡排序：第一轮，从第一个元素开始和相邻元素比较，如果前一个元素大，则交换位置，重复操作直到倒数第二元素和最后一个元素比较完，则最大的元素被交换放在数组最后一个元素的位置；第二轮重复之前的操作，直到找出次大元素；重复操作直到数组元素按升序排列

import java.util.Arrays;

public class ArrayDemo1 {
	
	public static void main(String[] args) {
		String week[];// 声明数组
		int[] score;// 声明数组
		int[] month = new int[12];// 声明并创建数组
		week = new String[] { "Monday", "Tuesday", "Wednesday", "Thursday",
				"Friday", "Saturday", "Sunday" };// 创建数组并赋值
		String[] Dayily = { "Monday", "Tuesday", "Wednesday", "Thursday",
				"Friday", "Saturday", "Sunday" };// 创建数组并赋值
		char[] newYear;
		newYear = new char[] { 'N', 'e', 'w', ' ', 'Y', 'e', 'a', 'r' };// 声明数组、创建数组并为数组赋值
		// 打印数组长度
		int nyLength = newYear.length;
		System.out.println("nyLength:" + nyLength);
		System.out.println("for循环遍历数组：");
		// for循环遍历数组
		for (int i = 0; i < nyLength; i++) {
			System.out.print(newYear[i]);
		}
		System.out.println();
		System.out.println("for each循环遍历数组：");
		// for each循环遍历数组
		for (char ny : newYear) {
			System.out.print(ny);
		}
		System.out.println();
		String[] copy1 = Arrays.copyOf(week, 3);// 数组拷贝
		System.out.println("ArraysArrays.copyOf()数组拷贝结束后的结果：");
		for (int i = 0; i < copy1.length; i++) {
			System.out.print(copy1[i] + "\t");
		}
		char[] copy2 = new char[8];
		System.out.println();
		System.out.println("System.arraycopy()数组拷贝结束后的结果：");
		
		System.arraycopy(newYear, 4, copy2, 0, 4);//数组拷贝
		for (int i = 0; i < copy2.length; i++) {
			System.out.print(copy2[i]);
		}
	}
}
public class ArrayDemo2 {
	// 交换数组元素
	static void swap(int[] arr, int a, int b) {
		int temp;
		temp = arr[a];
		arr[a] = arr[b];
		arr[b] = temp;
	}

	// 选择排序
	static void selectSort(int[] score) {
		for (int i = 0; i < score.length; i++) {
			for (int j = i + 1; j < score.length; j++) {
				if (score[i] > score[j]) {
					swap(score, i, j);
				}
			}
		}
	}

	// 冒泡排序
	static void bubbleSort(int[] score) {
		for (int i = 0; i < score.length; i++) {
			for (int j = 0; j < score.length - 1; j++) {
				if (score[j] > score[j + 1])
					swap(score, j, j + 1);
			}
		}
	}

	public static void main(String[] args) {
		int[] score = new int[] { 78, 35, 55, 92, 49, 36 };
		System.out.println("选择排序:");
		selectSort(score);
		for (int grade : score) {
			System.out.print(grade + "\t");
		}
		score = new int[] { 35, 78, 49, 36, 55, 92 };
		System.out.println("冒泡排序:");
		bubbleSort(score);
		for (int grade : score) {
			System.out.print(grade + "\t");
		}
	}
}

public class ArrayDemo3 {

	// 查找某个元素在数组中第一次出现的索引位置
	static int getIndex(int[] arr, int x) {
		int index = 0;
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] == x) {
				index = i;
				break;
			} else {
				index = -1;// 在数组arr中找不到x元素
			}
		}
		return index;
	}

	// 进制转换
	static String toBinary(int num) {

		return trans(num, 1, 1);
	}

	static String toOctonary(int num) {

		return trans(num, 7, 3);
	}

	static String toHexadecimal(int num) {

		return trans(num, 15, 4);
	}

	// 数组元素交换位置
	static String trans(int num, int base, int offset) {
		String str = "";
		if (num != 0) {
			StringBuffer sb = new StringBuffer();

			char[] table = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
					'a', 'b', 'c', 'd', 'e', 'f' };
			while (num != 0) {
				int temp = num & base;
				num = num >>> offset;

				sb.append(table[temp]);
				str = sb.reverse().toString();
			}
		} else {
			str = "0";
		}
		System.out.println(str);
		return str;

	}

	// 二分查找
	static int halfSearch_2(int[] arr, int num) {
		int min, max, mid;
		min = 0;
		max = arr.length - 1;
		mid = (min + max) / 2;
		while (num != arr[mid]) {
			if (num > arr[mid]) {
				min = mid + 1;
			} else {
				max = mid - 1;
			}
			if (min > max) {
				return -1;
			}
			mid = (min + max) / 2;
		}
		return mid;
	}

	public static void main(String[] args) {

		int[] hs = { 3, 5, 7, 9, 12, 23, 43, 53 };
		System.out.println(getIndex(hs, 7));
		toHexadecimal(60);
		toOctonary(60);
		toBinary(60);
		System.out.println(halfSearch_2(hs, 7));

	}
}