数组2
数组的排序-冒泡排序
口诀：N个数字来排队、两两相比小靠前、外层循环N-1、内层循环N-1-i
示意图：
public class Demo{
public static void main(String[] args){
int[] arr = {4,5,2,3,8,1};
for(int i =0;i<arr.length-1;i++){//控制比较次数 n-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;
}
}
}
for(int element:arr){
System.out.println(element);
}
}
}
数组的查找-顺序查找
含义：依次比较查找
public class Demo{
public static void main(String[] args){
int[] arr = {4,5,2,3,8,1};
int num = 3;
for(int i=0;i<arr.length;i++){
if(arr[i]==num){
System.out.println("查找数在数组中的下表为：" + i);
}
}
}
}
数组的查找-二分查找
理解：不断比较中间值与查找值的大小数组必须是有序的
示意图：
import java.util.Arrays;
public class Demo{
public static void main(String[] args){
int[] arr = {4,5,2,3,8,1};
int num = 3;
Arrays.sort(arr);
int min = 0;//最小值
int max = arr.length-1;//最大值
while(min <= max){
int mid = (min + max)/2;
if(num > mid){
min = mid+1;
}else if(num<mid){
max = mid-1;
}else{
System.out.println("查找数据的下标为：" + mid);
break;
}
}
}
}
数组的复制
浅表复制
将原数组地址复制给新数组新数组和原数组指向同一个地址
public class Demo01 {
public static void main(String[] args){
//原数组
String[] arr = {"1","2","3"};
//新数组
String[] newArr = arr;
//修改原数组
arr[1] = "1223";
//遍历新数组
for(String element:newArr){
System.out.println(element);
}
}
}
==缺点：==原数组发生改变，新数组也会发生改变
深表复制
修改原数组，新数组不会发生改变（原数组不会被回收，程序结束是被回收）
新数组和原数组指向两个不同地址
public class Demo02 {
public static void main(String[] args){
//原数组
String[] arr = {"1","2","3"};
//新数组
String[] newArr = new String[arr.length];
//将原数组的元素赋值给新数组
for(int i=0;i<arr.length;i++){
newArr[i] = arr[i];
}
//修改原数组
arr[1] = "1223";
//遍历新数组
for(String element:newArr){
System.out.println(element);
}
}
}
数组的扩容
扩容步骤：计算数组新长度，依次将原数组的值赋值给新数组
public class Demo03 {
//扩容步骤：计算数组新长度，依次将原数组的值赋值给新数组
public static void main(String[] args){
//原数组
String[] arr = {"1","2","3"};
int len1 = arr.length;//3
int newLen1 = arr.length + (arr.length>>1);//4
//新数组
String[] newArr = new String[newLen1];
//将原数组的元素赋值给新数组
for(int i=0;i<arr.length;i++){
newArr[i] = arr[i];
}
//遍历新数组
for(String element:newArr){
System.out.println(element);
}
}
}
数组的删除
方法一：使用新数组
public class Demo04 {
public static void main(String[] args){
//数组的删除步骤：只比较需要删除的元素，将原数组的其他值重新存储
//原数组
String[] arr = {"1","2","3"};
int len1 = arr.length;//3
int newLen1 = arr.length - (arr.length>>1);//4
//新数组
String[] newArr = new String[newLen1];
//
int index = 0;
//将原数组的元素赋值给新数组
for(String element:arr){
if(!element.equals("2")){
newArr[index++] = arr[index];
}
}
//遍历新数组
for(String element:newArr){
System.out.println(element);
}
}
}
==缺点：==数组作为存储数据的容器，删除会让容器越变越小
方法二：使用原数组
public class Demo04 {
public static void main(String[] args){
//数组的删除步骤：将原数组的每一个元素前移一位
//原数组
String[] arr = {"1","2","3"};
for(int i=0;i<arr.length-1;i++){
arr[i] = arr[i+1];
}
arr[arr.length-1] = null;
for(String element:arr){
System.out.println(element);
}
}
}
数组作为方法的参数和返回值
练习：设计一个方法，传入int类型的数组，返回最大值和最小值
public class Demo04 {
//设计一个方法，传入int类型的数组，返回最大值和最小值
public static void main(String[] args){
int[] arr = {54,4,85,1,24,1,2,5};
int[] minMax = getMaxMin(arr);
System.out.println(minMax[0]);
System.out.println(minMax[1]);
}
public static int[] getMaxMin(int... arr){
int max = 0;
int min = 0;
//比较逻辑：冒泡排序
for(int i = 0;i<arr.length-1;i++){
for(int j =0;j<arr.length-1-i;j++){
if(arr[j] > arr[j+1]){
int temp = arr[j+1];
arr[j+1] = arr[j];
arr[j] = temp;
}
}
}
min = arr[0];
max = arr[arr.length-1];
int[] maxMin = {max, min};
return maxMin;
}
}
可变参数
ps: getMaxMin(int... arr)其中的...就代表可变参数，实际上就是数组
public class Demo04 {
public static int[] getMaxMin(int... arr){
int max = 0;
int min = 0;
//比较逻辑：冒泡排序
for(int i = 0;i<arr.length-1;i++){
for(int j =0;j<arr.length-1-i;j++){
if(arr[j] > arr[j+1]){
int temp = arr[j+1];
arr[j+1] = arr[j];
arr[j] = temp;
}
}
}
min = arr[0];
max = arr[arr.length-1];
int[] maxMin = {max, min};
return maxMin;
}
==注意：==可变参数后不能接其他参数，如果有多个参数，可变参数必须放在最后
Arrays工具类
Arrays工具类是Java提供专门用于操作数组的类
工具类：该类中的方法都是静态的，直接使用类名调用
public class Demo04 {
public static void main(String[] args){
//Arrays工具类的使用，第一步：导包
int[] arr = {54,4,85,1,24,1,2,5};
//排序
Arrays.sort(arr);
for(int element:arr){
System.out.println(element);
}
//查找：二分查找
//返回规则：如果存在则返回下标；如果不存在则返回(-(insertion point) - 1) 即：如果存在的下标负数-1
int index = Arrays.binarySearch(arr,20);
System.out.print(index);
//拷贝数组:可指定新数组长度，不足的位置系统默认填充
int[] newArr = Arrays.copyOf(arr, 10);
for(int element:newArr){
System.out.println(element);
}
//拷贝数组区间：指定起始位置和终止位置拷贝片段 [起始位置，终止位置)
int[] newArr2 = Arrays.copyOfRange(arr, 2, 5);
for(int element:newArr2){
System.out.println(element);
}
//替换元素:所有元素替换为指定值
Arrays.fill(arr, 123);
for(int element:arr){
System.out.println(element);
}
//替换区间元素:指定区间，区间内所有元素替换为指定值 [起始位置，终止位置)
Arrays.fill(arr, 2,5,999);
for(int element:arr){
System.out.println(element);
}
//将数组转换为字符串
String str = Arrays.toString(arr);
System.out.println(str);
}
}
二维数组
静态初始化
package cn.qf.Demo01;
public class Demo05 {
//二维数组
public static void main(String[] args) {
//静态初始化：声明的同时赋值
//String[][] arr = new String[][]{{"1","2","3","4"},{"5","6","7","8","9"}};
//静态初始化：先声明，再赋值
//String[][] arr ;
//arr = new String[][]{{"1","2","3","4"},{"5","6","7","8","9"}};
//静态初始化：简化
String[][] arr = {{"1","2","3","4"},{"5","6","7","8","9"}};
for(String[] ss:arr){
for(String element:ss){
System.out.println(element);
}
}
}
}
动态初始化
package cn.qf.Demo01;
public class Demo05 {
public static void main(String[] args) {
String[][] arr = new String[2][];
String[] a1 = {"1","2","3","4"};
String[] a2 = {"5","6","7","8","9"};
arr[0] = a1;
arr[1] = a2;
for(String[] ss:arr){
for(String element:ss){
System.out.println(element);
}
}
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
