Java数组
数组Array
ArrayList
概念:一个连续的空间,存储多个相同数据类型的值
特点:
1. 类型相同
2. 长度固定
数组的创建
数组类型[] 数组名 = new 数组类型[数组长度];
//长度大小决定了你数组存储的大小
数组的声明和赋值:
数组的声明方式 | 具体声明赋值方法 |
先声明、分配空间 | 数据类型[] 数组名; 数组名 = new 数组类型[长度]; |
声明并分配空间 | 数据类型[] 数组名 = new 数据类型[长度]; |
声明并赋值{复杂版本} | 数据类型[] 数组名 = new 数据类型[]{value1,value2,....} |
声明并赋值(简单版本) | 数据类型 数组名[] = {value1,value2,.....} |
注意:数组的下标是从0开始计数的
数组的常见异常
数组的使用: 创建数组,依次赋值,依次取值
有效下标范围: 0~(数组长度-1)
常见的数组异常就是数组下标越界:
报错: java.lang.ArrayIndexOutOfBoundsException
: n ====>>此处的N表示的是你所访问的超出数组下标的无效下标
数组的遍历
- 就是从头到尾对数组每一个元素的访问
可以通过下标依次进行访问,也可以通过循环来获取每个下标对应的数组中的值
//通过下标依次获取(for循环)
public void Test(){
int i[] = {1,2,3,5,6,7,8};
for (int i = 0; i<i.length;i++){
System.out.println(i[i]);
}
}
数组的扩容
扩容的思路:
1. 创建大于原数组长度的新数组;
2. 将数组中的元素依次赋值给新的数组中
赋值的方式:
循环遍历依次赋值(for);
System.arraycopy
(原数组,原始数组起始,新数组,新数组长度,长度);
java.util.Array.copyOf
(原数组,新长度); //返回带有原值的新数组
数组类型的返回值
创建新数组,长度为原数组的两倍,新数组中保持原有数据,返回新数组
public static void main(String args[]){
int[] oa = {111,222,333,444,555,666};//0x0000A111
int[] na = expand(oa);
for (int i = 0;i<na.length;i++){
System.out.println(na[i]);
}
}//主函数
public static int[] expand(int[] oldArray){
int[] newArray = new int[oldArray.length*2];
for (int i = 0;i < oldArray.length;i++){
newArray[i] = oldArray[i];
}
return newArray;
}//数组扩容
可变长数组
public static void printArray(int... Array){
for (int i=0;i<Array.length;i++){
System.out.println(Array[i]);
}
}//可变长数组
排序算法
public static void bubbleSort(int[] array){
//相邻的两个数值比较大小,互换位置
System.out.println("bubbleSortTest=========");
System.out.println(Arrays.toString(array));
for (int i=0;i<array.length-1;i++){
for (int j=0;j<array.length-1-i;j++){
int temp = 0;
if (array[j]>array[j+1]) {
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
System.out.println(Arrays.toString(array));
forArray(array);
}//冒泡排序
public static void selectionSort(int[] array){
//固定值与其他值依次比较大小,互换位置
System.out.println("selectionSortTest========");
System.out.println("原始数据值:"+Arrays.toString(array));//转换成字符串输出
for (int j = 0;j<array.length;j++){//需要经过N次对比
int min_index = j;//假定这是最小值的下标
for (int i=j+1;i<array.length;i++){//每轮需要对比的个数
if (array[i]<array[min_index]){//比较前面确定的最小值和后面值的大小,如果后买的值值比面的值小就将下标进行替换
min_index=i;//把最小的下标转换过去
}
}
if (j != min_index){//比较两个下标是否一样,一样的话就直接跳过
int tmp = array[j];//将原始值赋值给tmp
array[j] = array[min_index];//将最小值赋值给array[i]
array[min_index] = tmp;//将最小值替换给tmp
}
}
System.out.println("原始数据值:"+Arrays.toString(array));
forArray(array);
}//选择排序
public static void jdkSort(int[] array){
//调用Java函数进行排序(java.util.Array.sort(数组名);===>默认升序)
Arrays.sort(array);
forArray(array);
}//JDK排序
二维数组
概念:二维数组为一个特殊的一维数组,其每个元素又是一个一维数组。
public static void PrintAr2(){
int[][] array;
array = new int[][]{{1,2,3,4},{4,3,2,1}};
// System.out.println(Arrays.toString(array[0]));//输出数组的内容
// System.out.println(array[1][1]);//访问通过数组的下标进行访问{}==》代表的就是一个维度,合数组访问类似
//遍历二位数组
for (int i=0;i<array.length;i++){for (int j=0;j<array[i].length;j++){
System.out.println(array[i][j]);
}}
}//二维数组创建和遍历
测试代码
public class demo_3 {
public static void main(String args[]){
int[] oa = {222,111,333,555,444,666};//0x0000A111
int[] na = expand(oa);
// for (int i = 0;i<na.length;i++){
// System.out.println(na[i]);
// }
// printArray(oa);
// bubbleSort(oa);
//
selectionSort(oa);
PrintAr2();
}//主函数
public static int[] expand(int[] oldArray){
int[] newArray = new int[oldArray.length*2];
for (int i = 0;i < oldArray.length;i++){
newArray[i] = oldArray[i];
}
return newArray;
}//数组扩容
public static void printArray(int... Array){
for (int i=0;i<Array.length;i++){
System.out.println(Array[i]);
}
}//可变长数组
public static void forArray(int[] array){
for (int i = 0; i < array.length; i++) {
System.out.println("Count is:" + array[i]);
}
}//遍历数组
public static void bubbleSort(int[] array){
//相邻的两个数值比较大小,互换位置
System.out.println("bubbleSortTest=========");
System.out.println(Arrays.toString(array));
for (int i=0;i<array.length-1;i++){
for (int j=0;j<array.length-1-i;j++){
int temp = 0;
if (array[j]>array[j+1]) {
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
System.out.println(Arrays.toString(array));
forArray(array);
}//冒泡排序
public static void selectionSort(int[] array){
//固定值与其他值依次比较大小,互换位置
System.out.println("selectionSortTest========");
System.out.println("原始数据值:"+Arrays.toString(array));//转换成字符串输出
for (int j = 0;j<array.length;j++){//需要经过N次对比
int min_index = j;//假定这是最小值的下标
// System.out.println(min_index);
for (int i=j+1;i<array.length;i++){//每轮需要对比的个数
if (array[i]<array[min_index]){//比较前面确定的最小值和后面值的大小,如果后买的值值比面的值小就将下标进行替换
min_index=i;//把最小的下标转换过去
}
}
if (j != min_index){//比较两个下标是否一样,一样的话就直接跳过
int tmp = array[j];//将原始值赋值给tmp
array[j] = array[min_index];//将最小值赋值给array[i]
array[min_index] = tmp;//将最小值替换给tmp
}
}
System.out.println("原始数据值:"+Arrays.toString(array));
forArray(array);
}//选择排序
public static void jdkSort(int[] array){
//调用Java函数进行排序(java.util.Array.sort(数组名);===>默认升序)
Arrays.sort(array);
forArray(array);
}//JDK排序
public static void PrintAr2(){
int[][] array;
array = new int[][]{{1,2,3,4},{4,3,2,1}};
// System.out.println(Arrays.toString(array[0]));//输出数组的内容
// System.out.println(array[1][1]);//访问通过数组的下标进行访问{}==》代表的就是一个维度,合数组访问类似
/** 遍历二位数组*/
for (int i=0;i<array.length;i++){for (int j=0;j<array[i].length;j++){
System.out.println(array[i][j]);
}}
}//二维数组创建和遍历
}