数组
1.数组的扩容
一个数组的工具类Arrays
1.1手动方法
- 创建新数组
- 把数组的值，按照其下标放到新数组中
- 重新赋值
/*
* 数组的扩容
*/
int[] arr2 = new int[3];
arr2[0] = 4;
arr2[1] = 6;
arr2[2] = 7;
//把arr2数组扩容为长度7
int[] newArr = new int[7];
for(int i=0; i<arr2.length; i++) {
newArr[i] = arr2[i];
}
arr2 = newArr;
1.2Arrays.copyOf()
语法：
Arrays.copyOf(需要扩容的数组，目标长度)
/*
* 数组的扩容
*/
int[] arr2 = new int[3];
arr2[0] = 4;
arr2[1] = 6;
arr2[2] = 7;
arr2 = Arrays.copyOf(arr2, 7);
1.3System.arraycopy()
语法：
System.arraycopy(原数组,原数组起始,新数组,新数组起始,长度)
/*
* System
* System.out.print() 在控制台打印
* System.arraycopy(原数组,原数组起始,新数组,新数组起始,长度)。
*
*/
int[] arr3 = new int[3]; // [41,6,77]
arr3[0] = 41;
arr3[1] = 6;
arr3[2] = 77;
//把arr3长度扩容7
int[] newArray = new int[7]; //[0,0,0,0,0,0,0]
System.arraycopy(arr3, 0, newArray, 5, 2);
2.数组的定义方式
//1. 首先定义时创建数组，然后逐个位置赋值
int[] arr = new int[3];
arr[0] = 8;
arr[1] = 24;
arr[2] = 16;
//2. 先声明，创建数组赋值给变量，然后逐个位置赋值
int[] arr2; //声明
arr2 = new int[3]; //初始化
//为每个位置赋值
arr2[0] = 8;
arr2[1] = 24;
arr2[2] = 16;
//3. 空数组，区别于null 长度为0
int[] arr3 = {};
/*
* 4. 可以在定义数组时，确定数组的长度，以及每个位置的值
*/
int[] arr4= {1,4,2,6,8};
3.数组类型参数
- 直接定义数组类型参数
public static 返回数据类型 方法名(数据类型[] 参数名){
}
- 定义可变参数
- 可变参数只能在参数列表的最后面
public static 返回数据类型 方法名(数据类型... 参数名){}
package com.qfedu;
public class Demo03 {
public static void main(String[] args) {
int[] arr= {1,2,3,4,22};
int max = max2(arr);
System.out.println(max);
int max2 = max2(4,33,2,3,4,6,8,123,5647);
System.out.println(max2);
}
//两个数最大值
public static int max01(int a,int b) {
int max=a>b?a:b;
return max;
}
//三个数最大值
public static int max02(int a,int b,int c) {
int max=a>b?a:b;
max=max>c?max:c;
return max;
}
public static int max(int[] arr) {
int max=arr[0];
for (int i=1; i <arr.length; i++) {
max = max>arr[i]?max:arr[i];
}
return max;
}
/*
* int... 可以在调用函数是直接在实参中填写，不需要重新定义数组
*/
public static int max2(int... arr) {
int max=arr[0];
for (int i=1; i <arr.length; i++) {
max = max>arr[i]?max:arr[i];
}
return max;
}
}
4.数组类型返回值
package com.qfedu;
import java.util.Arrays;
public class Demo04 {
/*
* 参数1为整数数组，参数2为目标长度 使数组扩容 如果目标长度小于原数组长度则不分割也不扩容
*/
public static void main(String[] args) {
int[] arr = { 1, 3, 6 };
int[] newArr = copyOf(arr, 2);
System.out.println(Arrays.toString(newArr));
}
public static int[] copyOf(int[] arr, int length) {
if (arr.length < length) {
int[] newArr = new int[length];
for (int i = 0; i < arr.length; i++) {
newArr[i] = arr[i];
}
return newArr;
}
return arr;
}
}
5.数组的排序
- 自己的算法
- 冒泡排序
- 选择排序
- ………………
- 使用工具类Arrays
5.1冒泡排序
从第一个位置开始，一直至倒数第二个元素，用前面的元素和后面的元素去比较，只要前面大于后面，就对换位置
每次都会确定一个位置的值，这种循环进行数组的长度减一次
package com.qfedu;
import java.util.Arrays;
public class Demo05 {
public static void main(String[] args) {
int[] arr = {3,5,2,7,6,1};
System.out.println(Arrays.toString(arr));
/*
* 从第一个位置开始，一直到倒数第二个元素，拿前面和后面的比较
* 只要前面的大于后面，就对换位置
*
*/
for(int i=0; i<arr.length-1-0; i++) {
if(arr[i] > arr[i+1]) {
int temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
System.out.println(Arrays.toString(arr));
for(int i=0; i<arr.length-1-1; i++) {
if(arr[i] > arr[i+1]) {
int temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
System.out.println(Arrays.toString(arr));
for(int i=0; i<arr.length-1-1-1; i++) {
if(arr[i] > arr[i+1]) {
int temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;
}
}
System.out.println(Arrays.toString(arr));
}
}
package com.qfedu;
import java.util.Arrays;
public class Demo05_2 {
public static void main(String[] args) {
int[] arr = {3,5,2,7,6,1};
//冒泡排序
for(int i=0; i<arr.length-1; i++) { //循环（长度-1）次
for(int j=0; j<arr.length-1-i; j++) {
if(arr[j] < arr[j+1]) {
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
System.out.println(Arrays.toString(arr));
//使用冒泡排序法，对数组进行降序排序
}
}
5.2选择排序
从第一个数开始，一直到结束，找到最小值的下标，然后第一个位置，和该下标的值，互换
从第二个数开始，一直到结束，找到最小值的下标，然后第二个位置，和该下标的值，互换
…
从第（length-1）个数开始，一直到结束，找到最小值的下标，然后第（length-1）个位置，和该下标的值，互换
package com.qfedu;
import java.util.Arrays;
public class Demo06 {
public static void main(String[] args) {
int[] arr = {3,5,2,7,6,1};
//选择排序
for(int i=0; i<arr.length-1; i++) { // i=0
int minIndex = i;
//确定从坐标i开始，到结束的最小值的下标
for(int j=i+1; j<arr.length; j++) {// 获取i坐标后，左右的下标
if(arr[j] < arr[minIndex]) {
minIndex = j;
}
}
//把i位置的值和minIndex下标的值互换
int temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
System.out.println(Arrays.toString(arr));
/*
* 使用选择排序 对数组进行降序排序
*/
}
}
5.3Arrays.sort排序
package com.qfedu;
import java.util.Arrays;
public class Demo07 {
public static void main(String[] args) {
int[] arr = { 3, 5, 2, 7, 9, 1 };
/*
* sort方法排序
*/
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
}
}
6.值传递和引用传递
6.1局部变量
定义在方法中，或者方法的参数都是局部变量
- 必须初始化才能使用
- 局部变量都有作用范围
- 作用范围就是离他最近的大括号，
- 在相同的作用范围内不能定义名称相同的变量
- 方法的参数也可以看作作用范围在该方法中的变量
- for循环中定义的变量，可以看过作用范围再该循环内的变量
6.2变量的存储
- 基本数据类型
- 变量和值都是放在栈中
- 引用数据类型
- 变量在栈里
- 数组在堆里
- 栈中变量指向堆中的对象
6.3 方法的执行
- 方法在执行的时候，jvm会为该方法在栈中分配内存的空间，保存方法在执行过程中定义的变量，或者运算的结果，方法一旦执行结束，这块内存区域就立马回收，里面所有的值都会被清空
- 如果参数为基本类型，则在调用方法时，传递该参数的是值
- 不会影响原变量的值
- 如果参数为引用类型，则在调用方法时，参数传递的时堆中值的地址
- 会影响原变量的值
package com.qfedu;
import java.util.Arrays;
public class Demo08 {
public static void main(String[] args) {
int n=8;
changeNum(n);
System.out.println(n);
int[] arr= {1,2,3};
changeArr(arr);
System.out.println(Arrays.toString(arr));
}
public static void changeNum(int n) {
n=7;
}
public static void changeArr(int[] arr) {
arr[1]=66;
}
}
7.二维数组
package com.qfedu;
public class Demo09 {
public static void main(String[] args) {
int[][] arr = new int[5][3];
arr[0][0] = 6;
arr[0][1] = 77;
arr[0][2] = 55;
//二维数组的循环
for(int i=0; i<arr.length; i++) {
int[] ar = arr[i];
for(int j=0; j<ar.length; j++) {
System.out.print(arr[i][j]+"\t");
}
System.out.println();
}
}
}
扫一扫
4980
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
