数组是一种线性结构,所有线性结构都有以下特点:
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();
}
}
}