JAVA基础之数组

数组是一种线性结构，所有线性结构都有以下特点：

1.有序 2.连续 3.增删慢 4.查找快

数组的三种声明方式：

int[]array=new int[4];
int[]array=new int[]{10,20,30,40};
int[]array={10,20,30,40};

数组是不可扩充的

数组的排序：

1.整型数组排序

package com.tao.array;

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;

public class Demo_IntArraySort {
	public static void main(String[] args) {
		Integer []array={95,23,8,47,-1};
		/*
		 * 自然排序
		 */
		//升序
		Arrays.sort(array);
		for(Integer i:array){
			System.out.println(i);
		}
		System.out.println("-------");
		//降序
		Arrays.sort(array, Collections.reverseOrder()); //
		for(Integer i:array){
			System.out.println(i);
		}
		System.out.println("-------");
		
		/*
		 * 自定义排序
		 */
		//升序
		Arrays.sort(array, new Comparator<Integer>() {     //泛型必须是类类型

			@Override
			public int compare(Integer o1, Integer o2) {
				return o1-o2;//负值，o1在o2前边；0，两数相等，正值，o1在o2后边
			}  
		});
		for(Integer i:array){
			System.out.println(i);
		}
		System.out.println("-------");
		//降序
				Arrays.sort(array, new Comparator<Integer>() {     //参数必须是类类型

					@Override
					public int compare(Integer o1, Integer o2) {
						return (o1-o2)*-1;//乘-1，倒置
					}  
				});
				for(Integer i:array){
					System.out.println(i);
				}
	}
}

2.字符型排序

package com.tao.array;

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;

public class Demo_StringArraySort {
	public static void main(String[] args) {
		String[] array={"baidu","qq","360","jd","taobao"};
	/*
	 * 自然顺序
	 */
	//1.升序
		Arrays.sort(array);
		for (String str : array) {
			System.out.println(str);
		}
		System.out.println("--------");
	//2.降序
		Arrays.sort(array,Collections.reverseOrder());//翻转
		for (String str : array) {
			System.out.println(str);	
		}
		System.out.println("--------");
	/*
	 * 自定义顺序
	 */
		//1.升序
		Arrays.sort(array, new Comparator<String>() {  //泛型必须是类类型

			@Override
			public int compare(String o1, String o2) {
				// TODO Auto-generated method stub
				return o1.compareTo(o2);
			}
		});
		for (String str : array) {
			System.out.println(str);	
		}
		System.out.println("--------");
		////2.降序
		Arrays.sort(array, new Comparator<String>() {

			@Override
			public int compare(String o1, String o2) {
				// TODO Auto-generated method stub
				return (o1.compareTo(o2))*-1;  //倒置
			}
		});
		for (String str : array) {
			System.out.println(str);	
		}
		
	}

}

3.字符串汉语排序

package com.tao.array;

import java.text.Collator;
import java.util.Arrays;
import java.util.Collections;
import java.util.Locale;
/**
 * 汉语排序
 * @author 天外飞星

 *
 */
public class ChineseCharacterSort {
	public static void main(String[] args) {
		String[]array={"腾讯","百度","360","京东","淘宝","alipay"};
		//升序
		//Arrays.sort(array, Collator.getInstance(Locale.CHINESE));
		//降序
		//Collator.getInstance(Locale.CHINESE)获取当前所需语言环境的
		Arrays.sort(array, Collections.reverseOrder(Collator.getInstance(Locale.CHINESE)));
		for (String s : array) {
			System.out.println(s);
		}
	}
}

排序例子

package com.tao.array;

import java.util.Arrays;
import java.util.Comparator;

/**
 * 扑克牌排序
 * 
 * @author 天外飞星 2 3 4 5 6 7 8 9 10 11 12 13 1 此程序目的是：自定义排序，打破传统排序方法，按照自己的想法进行排序
 * 
 */
public class PuKeSort1 {
	public static void main(String[] args) {
		demo1(); // 看成字符串类型
		demo2();// 看成整型
	}

	private static void demo2() {
		Integer[] pukes = { 2, 4, 3, 1, 5, 7, 6, 8, 9, 10, 11, 12, 13 };
		Arrays.sort(pukes, new Comparator<Integer>() {
			@Override
			/*
			 * 对于1进行特殊处理，总之让1跟所有比较都排在最后
			 */
			public int compare(Integer o1, Integer o2) {
				if (1 == o1) {
					return 1; // 返回正值，是使o1在o2后边
				} else if (1 == o2) {
					return -1; // 返回负值，是使o2在o1后边
				}
				return o1.compareTo(o2);
				// return o2.compareTo(o1); //降序
			}
		});
		for (Integer s : pukes) {
			System.out.print(s + " ");
		}
	}

	private static void demo1() {
		String[] pukes = { "3", "4", "5", "6", "7", "8", "9", "10", "1", "2",
				"11", "13", "12" };

		Arrays.sort(pukes, new Comparator<String>() {

			@Override
			public int compare(String o1, String o2) {
				if ("10".equals(o1)) { // 字符串"10"是"1 0"，所以要特殊处理，以下类似
					o1 = "A"; // o1变为A,方便比较
				} else if ("11".equals(o1)) {
					o1 = "B";
				} else if ("12".equals(o1)) {
					o1 = "C";
				} else if ("13".equals(o1)) {
					o1 = "D";
				}
				if ("1".equals(o1)) {
					o1 = "E"; // 使1的地位最高（E的ASCLL比前边的都大）
				} else if ("10".equals(o2)) {
					o2 = "A";
				} else if ("11".equals(o2)) {
					o2 = "B";
				} else if ("12".equals(o2)) {
					o2 = "C";
				} else if ("13".equals(o2)) {
					o2 = "D";
				} else if ("1".equals(o2)) {
					o2 = "E";
				}

				return o1.compareTo(o2);
				// return o2.compareTo(o1); //降序
			}

		});
		for (String s : pukes) {
			System.out.print(s + " ");
		}
		System.out.println();
	}
}
/*
 * 如果是3 4 5 6 7 8 9 10 J Q K A 2排序， 同样道理，利用Demo1的方法试试做
 */

数组的扩充

package com.tao.array;

import java.util.Arrays;

/**
 * 数组的扩充
 * @author 天外飞星

 *
 */
public class ArrayExpand {

	public static void main(String[] args) {
		int []arr={1,2,3,4,5};
		//Arrays.copyOf(源数组,新数组长度)
		//arr=Arrays.copyOf(arr, 7);   //F1，不灵活，但简单，适用于全部拷贝
		
		int [] newArr=new int[7];             //F2，灵活，复杂，功能性高
		//5个参数含义：arraycopy(source源数组，srcPosition源数组拷贝起始位置，destination目标数组,/destposition目标数组的起始位置 ，length拷贝长度)
		System.arraycopy(arr, 0,newArr, 0, arr.length);
		arr=newArr;
		for(int i=0;i<arr.length;i++){
			System.out.println(arr[i]);
		}
	}

}

数组的插入与删除

package com.tao.array;
/**
 * 数组的插入和删除
 * @author 天外飞星
 下标 0 1 2 3 4  5  6  7 8 9 10 11   
 *  1 2 3 4 5  6   7 8 9 10 0  0
 *  1 2 3 4 5 -1   6 7 8 9  0  0
 */
public class ArrayEdit {
	public static void main(String[] args) {
		/*
		 * 创建长度为12的数组 1 2 3 4 5 6 7 8 9 10 0 0
		 * 注：数组末尾是0是因为为插入-1做准备
		 */
		int[]arr=new int[12];
		for(int i=0;i<10;i++){
			arr[i]=i+1;
		}
		/*
		 * 在5-6之间插入-1
		 */
		//从源程序下标为5开始长度为6的个数赋值给目标程序下标为6开始长度为6，此题中源程序=目标程序
		System.arraycopy(arr, 5, arr, 6, 6);  //此时的结果1 2 3 4 5 5 6 7 8 9 10 0
		arr[5]=-1;  //所谓的插入即覆盖
		for (int i : arr) {
			System.out.print(i+" "); //1 2 3 4 5 -1 6 7 8 9 10 0
		}
		System.out.println();
		/*
		 * 把刚刚插入的-1删掉
		 */
		System.arraycopy(arr, 6, arr, 5, 6);//此时的结果1 2 3 4 5 6 7 8 9 10 10 0
		arr[10]=0;
		for (int i : arr) {
			System.out.print(i+" ");
		}
	}
}

不规整的二维数组

package com.tao.array;
/**
 * 
 * @author 天外飞星
 *
 */
public class DoubleArray {
	public static void main(String[] args) {
		/*
		 * 不规整二维数组的存值取值与遍历
		 */
		//盛装三个班学生成绩的数组
		
		//装入第一个班学生的成绩(共4名同学)
		int[][]arr=new int[3][];//知道有3个班，但不知每班人数
		arr[0]=new int[4];  //不规整二维数组必须有这样的话，声明二维数组第一行几列行有几个元素
		arr[0][0]=20;
		arr[0][1]=30;
		arr[0][2]=40;
		arr[0][3]=70;
		//装入第二个班学生的成绩(5名同学)
		arr[1]=new int[]{45,62,74,85,77}; //等同于上边的写法，这样子简单一点 。 声明二维数组第二行几列行有几个元素
		//装入第三个班学生的成绩(3名同学)
		arr[2]=new int[]{67,52,91};
		//取值
		System.out.println(arr[1][1]);
		//不规整二维数组只能采用加强for循环输出，因为双重for循环的内循环个数不唯一（规则的二维数组可以使用双重for循环遍历）
		for (int[] is : arr) {
			for (int i : is) {
				System.out.print(i+" ");
			}
			System.out.println();
		}
		
	}
}