数组操作案例
数组的增加
int[] scoers = { 12, 34, 45, 43, 32, 54, 56, 23, 0, 0 };// 定义存放数组，
System.out.println("添加前的：");
for (int i : scoers) {
System.out.print(i + "\t");// 用增强for--each循环一一显示值，用增强for循环适合查询，不适合计算
}
System.out.println();
int num = 450;// 要添加的值
for (int i = scoers.length - 1; i > 4; i--) {// 指定位置，指定的元素像后移动一位 4位添加值的坐标
scoers[i] = scoers[i - 1];// 已自动变量i
}// 将指定元素添加到指定位置
scoers[4] = num;
System.out.println("添加后的：");
for (int i : scoers) {// 输出添加后的数据
System.out.print(i + "\t");
} }
数组的删除
两种分为下标与不知道下标的时候
int [] scoers={23,45,67,7,65,43,32,21};
System.out.print("删除前\t");
for(int i:scoers){
System.out.print(i+"\t");//如果输入scoers会出现乱码
}
System.out.println();
int Index=2;//指定要删除的小标
for(int i=Index;i<scoers.length-1;i++){//scoers.length-1相当于减掉了0；下标是从0开始的
scoers[i]=scoers[i+1];//删除指定的下标，后面的元素向前移一位，
}
scoers[scoers.length -1]=0;//最后一位元素为0
System.out.print("删除后\t");
for(int i:scoers){
System.out.print(i+"\t");
}```
## 不知道下标
```java
int [] arr={23,44,54,65,43,32,21,12,};//创建数组arr；
int[] asd=new int[arr.length-1];//在创建数组asd，长度小于arr数组1位
int Index=3;//要删除的下标
System.out.print("删除前：\t");
for(int i:arr){
System.out.print(i+"\t");
}
System.out.println();
System.out.print("删除后\t");
System.arraycopy(arr, 0,asd,0, Index);//从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
System.arraycopy(arr, Index+1, asd, Index, asd.length -Index);//arr是要复制的数组，Index+1要从复制的数组的第几个开始，
for(int i=0;i<asd.length ;i++){//asd是要复制到那，Index要复制到的数组第几个开始，asd.length-Index是复制的长度
System.out.print(asd[i]+"\t");
}
求数组的平均值，最大，最小值
double [] dou =new double []{34,55,76};
double[] result = new double[3];
double max = dou[0], min = dou[0], sum = dou[0];
for (int i = 1; i < dou.length; i++) {
max = max > dou[i] ? max : dou[i];// 最大值
min = min < dou[i] ? min : dou[i];// 最小值
sum += dou[i];// 求所有元素的累加和
}
result[0] = max;
result[1] = min;
// 求平均值
result[2] = sum / dou.length;
System.out.println("最大值："+result[0] +"最小值："+result[1]+"平均值："+result[2]);
实例2
// 求最大值与最小值与下标的大小值
public static void main(String[] args) {
int[] scoers = { 23, 45, 76, 78, 89, 76, 45, 67, 90, 98, 76, };// 建了数组并且给与赋值
System.out.print("排序前：");
for (int a : scoers) {// for增强循环，适合于查询，不适合于计算
System.out.print(a + "\t");
}
int max = scoers[0];// 最大值
int min = scoers[0];// 最小值
for (int i = 0; i < scoers.length; i++) {// 定义i是下标，scoers.lenght是下标的总长度
if (max < scoers[i]) {// 当Scoers[i]大于max是赋值给max
max = scoers[i];
}
if (min > scoers[i]) {// 当Scoers[i]小于min是赋值给min
min = scoers[i];
}
}
System.out.println();
System.out.println("最大值:" + max);
System.out.println("最小值：" + min);
int maxIndex = 0;// 求最大的下标
int minIndex = 0;// 求最小的下标
for (int i = 0; i < scoers.length; i++) {// 定义i是下标，scoers.lenght是下标的总长度
if (maxIndex < i) {// 当下标i大于maxInex最大是赋值给maxIndex
maxIndex = i;
}
if (minIndex > i) {// 当下标i小于maxInex最小是赋值给maxIndex
minIndex = i;
}
}
System.out.println("最大的下标：" + maxIndex);
System.out.println("最小的下标：" + minIndex);
}
数组值的复制
// 创建数组
int[] array1 = { 1, 2, 3 };
int[] array2 = { 4, 5, 6 };
System.out.println("两个数组的初始值：");
for (int i = 0; i < array1.length; i++) {
System.out.println("array1[" + i + "]=" + array1[i]);
}
for (int i = 0; i < array2.length; i++) {
System.out.println("array2[" + i + "]=" + array2[i]);
}
array1 = array2;
System.out.println("在执行数组复制后，两个数组的值：");
// 打印输出复制后的值
for (int i = 0; i < array1.length; i++) {
System.out.println("array1[" + i + "]=" + array1[i]);
}
for (int i = 0; i < array2.length; i++) {
System.out.println("array2[" + i + "]=" + array1[i]);
}
System.out.println("将数组array2的一个元素改变");
array2[2] = 8;
System.out.println("array2[2]=" + array1[2]);
System.out.println("array1[2]=" + array1[2]);
System.err.println("异常分解线");
String[] str1 = { "A", "B", "c" };
String[] str2 = { "D", "E", "F" };
for (int i = 0; i < str1.length; i++) {
System.out.println("str1[" + i + "]=" + str1[i]);
}
for (int i = 0; i < str2.length; i++) {
System.out.println("str2[" + i + "]=" + str2[i]);
}
str1 = str2;
System.out.println("在复制后的字母");
for (int i = 0; i < str1.length; i++) {
System.out.println("str1[" + i + "]=" + str1[i]);
}
for (int i = 0; i < str2.length; i++) {
System.out.println("str2[" + i + "]=" + str2[i]);
}
多维数组
创建二维数组
System.out.print("输出：");
for (int i = 0; i < arr.length; i++) {//显示数组的每一个元素
for (int j = 0; j < arr[i].length; j++) {//显示每一行的元素arr[i].length,下标i的长度
System.out.print("arr[" + i + "][" + j + "]=" + arr[i][j] + "\t");//打印i的值arr[0--3][]这里一一对应的值
}
System.out.println();//换行
}
System.out.print(arr.length + "\t");//arr[][]数组的总长度
System.out.print(arr[0].length + "\t");//
System.out.print(arr[1].length + "\t");
System.out.print(arr[2].length + "\t");
System.out.print(arr[3].length + "\t");
}
在这里插入代码片
二维数组的行互换
public static void main(String[] args) {
/**
* 二维数组中的行列互换
* */
int arr[][] = new int[][]{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
System.out.println("行列互换前：");
printArray(arr);
int arr2[][] = new int[arr.length][arr.length];
for (int i = 0; i < arr.length; i++) {//调整数组行列数据
for (int j = 0; j < arr[i].length; j++) {
arr2[i][j] = arr[j][i];
}
}
System.out.println("行列互换后：");
//输出互换后的二维数组
printArray(arr2);
}
public static void printArray(int[][]arr){
for(int i=0;i<arr.length;i++){//遍历数组
for(int j=0;j<arr.length;j++){
System.out.print(arr[i][j]+"");//不换行输出数组元素
}
System.out.println();//换行
}
}
创建多维数组
// 创建的1种方式
int[][] two1 = { { 1, 2, 3, 4, 5 }, { 6, 7, 8, 9, 10 },
{ 11, 12, 13, 14, 15 }, { 16, 17, 18, 19, 20 },
{ 21, 22, 23, 24, 25 } };
// 创建的2种方式
int[][] Two = new int[5][5];
int k = 1;
for (int i = 0; i < Two.length; i++) {
for (int j = 0; j < Two[i].length; j++)
Two[i][j] = k++;
}
System.out.println("输出two1数组");
for (int i = 0; i < two1.length; i++) {
for (int j = 0; j < two1[i].length; j++) {
System.out.print(two1[i][j] + "\t");
}
System.out.println();
}
System.out.println("输出Two数组");
for (int i = 0; i < Two.length; i++) {
for (int j = 0; j < Two[i].length; j++) {
System.out.print(Two[i][j] + "\t");
}
System.out.println();
}
System.out.println("多维数组************");
int[][] two = new int[4][];
two[0] = new int[1];
two[1] = new int[2];
two[2] = new int[3];
two[3] = new int[4];
int a = 1;
for (int i = 0; i < two.length; i++) {
for (int j = 0; j < two[i].length; j++)
two[i][j] = k++;
}
System.out.println("所得到的不规则数组为：");
for (int i = 0; i < two.length; i++) {
for (int j = 0; j < two[i].length; j++)
System.out.print(two[i][j] + "\t");
System.out.println();
}
多维数组值相加
int [][]arr={{1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7},{4,5,6,7,8}};//第一个矩阵
int [][]arr2={{5,4,3,2,1},{6,5,4,3,2},{7,6,5,4,3},{8,7,6,5,6}};//第二个矩阵
int [][]result=new int[4][5]; //两个矩阵相加的结果result[][]的长度要分别比arr[][]的大或相等
for(int i=0;i<arr.length;i++){//显示数组的每一个元素
for(int j=0;j<arr[i].length;j++){//显示每一行的元素arr[i].length,下标i的长度
result[i][j]=arr[i][j]+arr2[i][j];//两个矩阵相加的结果
}
}
for(int i=0;i<result.length;i++){//输出矩阵显示数组的每一个元素
for(int j=0;j<result[i].length;j++){//显示每一行的元素arr[i].length,下标i的长度
System.out.print(result[i][j]+"\t");
}
System.out.println();
}
}
Array工具类提供的一些方法
public static void main(String[] args) {
int[] intArray = new int[10];
System.out.println("整型数组原始长度是：" + intArray.length);
Arrays.fill(intArray, 8);//将数组中的元素全部赋值为8
System.out.println("整型数组的内容："+Arrays.toString(intArray));
int[] newIntArray = (int[]) increaseArray(intArray);//增加数组的长度
System.out.println("整型数组扩展后长度是：" + newIntArray.length);
System.out.println("整型数组的内容："+Arrays.toString(newIntArray));
}
public static Object increaseArray(Object array) {
Class<?> clazz = array.getClass();// 获得代表数组的Class对象
if (clazz.isArray()) {//如果输入是一个数组
Class<?> componentType = clazz.getComponentType();//获得数组元素的类型
int length = Array.getLength(array);//获得输入的数组的长度
Object newArray = Array.newInstance(componentType, length + 5);//新建数组
System.arraycopy(array, 0, newArray, 0, length);//复制原来数组中的所有数据
return newArray;//返回新建数组
}
return null;//如果输入的不是数组就返回空
}
- Array类提供了动态创建和访问Java数组的方法，Array允许在执行get()或set()方法操作期间进行扩展转换，但如果收缩转换
- 则会抛出异常IllegalArgumentException。为了创建新的数组对象。需要使用newinstance()方法，他可以根据指定的元素类型和长度创建新的
- 数组
- public static Object newInstance(class<?> componentType,int length)throws NegativeArraySizeException
- componentType:表示新数组的组件类型的Class对象、
- length:新数组的长度、
- 为了获得给定数组的长度，需要使用getLength()方法
- public static int getLength(Object array)throws IllegalArgumentException
- array:一个数组
- 对于Java的数组不管几位，都属于Object类型
- **/
int[] arr = { 34, 45, 56, 67, 78, 76, 66, 54, 43, 32 };
int[] arr2 = { 45, 56, 32, 45, 76, 78, 98, 76, 54, 34 };
int index = Arrays.binarySearch(arr, 78);// 用二分法查元素下标arr数组，78值
System.out.println("78的索引" + index);
int[] arr3 = Arrays.copyOf(arr2, 14);
System.out.println();// 将arr2复制给arr3,长度是14
System.out.print("复制给arr3");
System.out.println(Arrays.toString(arr3));
System.out.println();
System.out.print("遍历arr数组");
System.out.println(Arrays.toString(arr));
System.out.println();
System.out.println("判断arr数组与arr2数组是不相等");
System.out.println(Arrays.equals(arr, arr2));
System.out.println();
System.out.println("对数组部分排序arr0-3");
Arrays.sort(arr, 0, 3);
System.out.println(Arrays.toString(arr));// 打印数组
Arrays.sort(arr);
System.out.println();
System.out.print("排序后的");
System.out.println(Arrays.toString(arr));
System.out.println();
Arrays.fill(arr, 0, 3, 0);
System.err.println(Arrays.toString(arr));// 是字体变红色
数组的排序
sort排序
实例一:
int[] array = new int[8];
//生成数组长度为10的数组
Random random = new Random();// 创建随机数对象
for (int i = 0; i < array.length; i++) {// 初始化数组元素
array[i] = random.nextInt(50);// 生成50以内的随机数
System.out.print(array[i]+" ");
}
/**
* 选择排序法从数组中挑选最大值放到数组最后，重复不处理在程序默认数组可重复值的情况 建议使用选择排序方法
* 他的数据交换次数较少，相对速度也会提高,取决于数组重复值得数量
* */
int index;
for (int i = 1; i < array.length; i++) {//遍历数组
index = 0;//索引为0
for (int j = 1; j <= array.length - i; j++) {//遍历数组的第二个数值
if (array[j] > array[index]) {
index = j;// 查找最大值
}
}
// 交换在位置array.length-i和index(最大值)两个数
int temp = array[array.length - i];
array[array.length - i] = array[index];
array[index] = temp;
}
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
实例二：
* Sort方法数组排序
* 将输入的字符串中的空格为分割符，字符串--转换成字符串数组---转换成证书数组---调用Arrays类的Sort()方法对其进行排序
* Arrays.sort(array) 有很多重载格式，可以接收任何数据类型的数组并执行不同类型的排序，
*
* **/
Scanner input = new Scanner(System.in);
System.out.println("请输入数组：");
String text = input.next().toString();// 获取用户输入
text=text.trim(); //去除首尾空格
if("".equals(text)){
JOptionPane.showMessageDialog(null,"请输入要排序的数组内容");
return;
}
String[] arrayStr = text.split(",");// 拆分输入为数组
int[] array = new int[arrayStr.length];// 创建整数类型数组
for (int i = 0; i < array.length; i++) {// 初始化整形数组
array[i] = Integer.parseInt(arrayStr[i]);
}
Arrays.sort(array);// 使用sort方法对整形数组进行排序
for (int value : array) {// 输出排序后的数组内容
System.out.println(value + " ");
}
在这里插入代码片
实例三：
* 反转排序法， 反转不等于 倒序排序 ，反转只是将数组元素的顺序进行颠倒，并不是对其执行排序操作，
* 倒序排序 则是对数组中的元素进行从大到小的排序\
* 反转算法：将数组最后一个元素与第一个元素替换将数组最后二个元素与第二个元素替换，依次类推
* 反转数组元素是对数组两边的元素进行替换，所以只需要循环数组长度的半数，例如：长度为6的一位数组进行反转,
* 只需要循环6/2 及3次
*
* */
Scanner scanner =new Scanner(System.in);
String inText = scanner.next();// 获取用户输入
String[] array = inText.split(",");// 把字符串分割为数组
int len = array.length;// 获取数组长度
for (int i = 0; i < len / 2; i++) {// 反转数组元素
String temp = array[i];
array[i] = array[len - 1 - i];
array[len - 1 - i] = temp;
for (String string : array) {// 数组排序过程
System.out.println( "String:"+ string);
}
}
在这里插入代码片
选择性排序
/**原理：首先在未排序序列中找到最小的元素，存放到排序序列的起始位置，然后，
* 再从剩余未排序的元素中寻找最小的元素，放到排序序列起始位之后。依次类推，直到所有的元素均排序完毕。
**/
int[] intarray = { 1, 423, 405, 66, 7779, 555, 8, 4 };
int Keyvalue;//数值
int index; //数组的坐标
int temp;//临时数据
//开始排序
for (int i = 0; i < intarray.length; i++) {
// 数组的下标
index = i;
// 数组的值
Keyvalue = intarray[i];
for (int j = i; j < intarray.length; j++) {
if (intarray[j] < Keyvalue) {
index = j;
Keyvalue = intarray[j];
}
}
temp = intarray[i];
intarray[i] = intarray[index];
intarray[index] = temp;
}
System.out.println("排序后的数组：");
for (int c : intarray) {
System.out.print(c + "\t");
}
在这里插入代码片
冒泡排序
实例一
/**
* 冒泡排序
* 0.一共有n个元素，整个数列可以分为无序数列和有序数列，初始状态下，
* 整个数列都是无序的，每执行一趟循环，有序数列数量加1
* 1.需要n-1趟循环，最次循环保证无序数列中最后一个数最大，n-1趟循环后，整个数列都是有序数列
* 2.每1趟循环从第一个元素开始比较，依次比较相邻的两个元素，到无序数列的最后一个元素结束
* 3.最多n-1趟，为了提高效率，如果已经有序，就没有必要进行后续趟的比较
* 如何判断已经有序：一次交换也没有发生
* @author liukaili
*
* 数组是引用类型，使用数组做参数，可以通过方法调用改变原来数组中的值
*
*/
int[]arr={23,44,32,56,54,43,65,75,89,78};
int n=arr.length ;//首先声明一个变量n并将值arr.length付给n 10;
for(int i=0;i<n-1 ;i++){//大循环n-1 9;
for(int j=0;j<n-1-i;j++){//小循环是n-1-i 9;
if(arr[j]<arr[j+1]){//判断arr[j]邻近的值arr[j+1]，谁大arr[j+1]也就是j只能加1
int temp;//声明第3个变量进行转换
temp=arr[j];
arr [j]=arr[j+1];
arr[j+1]=temp;
}
}
}
for(int asd:arr){
System.out.print(asd+"\t");
}
实例二：
快速排序方法
static int[] array = new int[10];
public static void main(String[] args) {
Random random = new Random();// 创建随机数对象
String text = "";
for (int i = 0; i < array.length; i++) {// 初始化数组元素
array[i] = random.nextInt(90);// 生成50以内的随机数
text += (array[i] + " ");// 把数组元素显示
}
quickSort(array, 0, array.length - 1);// 调用快速排序算法
}
/**
* 快速排序算法，是对冒泡排序算法的一种改进
* 通过一趟排序将要排序的数据分割成独立的两部分其中一部分的所有数据都比另外一部分的所有数据小，然后在按此方法对这两部分数据分别进行快速排序，
* 整个排序过程可以递归进行，以此是整个数据变成有序序列数组A[1]....A[N],首先任意选取一个数据(通常选用第一个数据)作为关键数据
* 然后将所有比他小的数都放到他前面。所有比它大的数都放到它后面，这个过程称为一趟快速排序，递归调用此过程，即可实现数组的快速排序。
* */
private static void quickSort(int sortarray[], int lowIndex, int highIndex) {
int lo = lowIndex;// 记录最小索引
int hi = highIndex;// 记录最大索引
int mid;// 记录分界点元素
if (highIndex > lowIndex) {
mid = sortarray[(lowIndex + highIndex) / 2];// 确定中间分界点元素值
while (lo <= hi) {
while ((lo < highIndex) && (sortarray[lo] < mid))
++lo;// 确定不大于分界元素值的最小索引
while ((hi > lowIndex) && (sortarray[hi] > mid))
--hi;// 确定大于分界元素值的最大索引
if (lo <= hi) {// 如果最小与最大索引没有重叠
swap(sortarray, lo, hi);// 交换两个索引的元素
++lo;// 递增最小索引
--hi;// 递减最大索引
}
}
if (lowIndex < hi)// 递归排序没有未分解元素
quickSort(sortarray, lowIndex, hi);
if (lo < highIndex)// 递归排序没有未分解元素
quickSort(sortarray, lo, highIndex);
}
}
private static void swap(int swapArray[], int i, int j) {
int temp = swapArray[i];// 交换数组元素
swapArray[i] = swapArray[j];
swapArray[j] = temp;
for (int k = 0; k < array.length; k++) {// 把数组元素显示到文本域
System.out.print(array[k] + " ");
}
System.out.println("/t");
}
4249
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
