java基础-day03-数组

于 2023-03-17 21:51:32 发布
阅读量601 收藏 1
点赞数
分类专栏： java 文章标签： java Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42812128/article/details/129444614
版权
文章详细介绍了Java中数组的各种操作，包括数组的初始化、赋值、拷贝、翻转、扩容、排序以及查找等。提供了不同的实现方法，如简单的赋值、使用循环的数组翻转、冒泡排序算法和查找特定元素。此外，还涉及到了二维数组的概念及杨辉三角形的生成。
摘要由CSDN通过智能技术生成

数组定义

题目1：

public class Hw1{
    
    public static void main(String[] args){
        char[] c1 = new char[26];
        c1[0] = 'A';
        for (int i = 1; i <= 25; i++){
            c1[i] = (char)(c1[0] + i);
        }
        System.out.println(c1);
//自己写的烂方法：
        char[] c2 = new char[26];
        for (int i = 0; i < c2.length; i++){
            c2[i] = 'A' + i;
        }
        System.out.println(c2);
// 老师给的牛犇的方法
    }
}

题目2：

public class Hw1{
    
    public static void main(String[] args){
    int[] a = {4, -1, 9, 10, 23};
    int max = a[0];
    int indx = 0;
    for (int i = 0; i < a.length; i++){
        if (max <= a[i]){
            max = a[i];
            indx = i;
        }
    }
    System.out.println("最大值是"+max+" 下标是"+indx);

    }
}

数组赋值

数组的拷贝

将int[] arr1 = {1, 2, 3} 拷贝到arr2数组，要求数据空间是独立的

  1. 创立新的数组，开辟新空间

  1. 遍历arr1，把每个元素拷贝到arr2的对应位置

数组翻转

思路1：注意吧len = arr.length

public class Hw1{
    public static void main(String[] args){
    int[] arr = {11, 22, 33, 44, 55, 66};
    //把arr[1]和arr[5]交换，
    //  arr[2]和arr[4]交换...
    int len = arr.length;
    for(int i = 0; i < len / 2; i++){
        int temp = arr[i];
        arr[i] = arr[len - i - 1];
        arr[len - i - 1] = temp;
        }
    for(int i = 0; i < len; i++){
        System.out.println(arr[i]);
    }
  }
}

思路2：逆序赋值法

  1. 先开辟一个新的数组

  1. 逆序遍历arr1, 顺序遍历新数组，把arr1的那个数据反着传给新数组

  1. 记得要把arr2的地址给到arr1，不然arr1没改变，然后会被java垃圾回收机制收走

  1. 注意：主要是那个arr2的下标用j，仔细看一下

public class Hw1{
    public static void main(String[] args){
    int[] arr1 = {11, 22, 33, 44, 55, 66};
    int[] arr2 = new int[arr1.length];
    for(int i = arr1.length - 1, j = 0; i >= 0; i--, j++){
        arr2[j] = arr1[i];
    }
    arr1 = arr2;
    for (int i = 0; i < arr2.length; i++){
        System.out.print(arr1[i]+"\t");
    }
  }
}

数组扩容

要求：给arr添加内容，先问用户要不要添加，y/n

思路：

  1. 开辟新数组，长度是原数组+1，把原数组依次赋值

  1. 在屁股上加一个

  1. 改指针

  1. 用do-while + break控制用户要不要添加

import java.util.Scanner;
public class Lianxi{
    public static void main(String[] args){
        int arr[] = {1, 2, 3};
        do{
            Scanner myScanner = new Scanner(System.in);
            System.out.println("请问您是否要为数组添加一个数据？");
            char key = myScanner.next().charAt(0);
            if (key == 'n'){
                break;
            }
            int[] arr2 = new int[arr.length + 1];
            System.out.println("请输入您要添加的数据？");
            int num = myScanner.nextInt();
            for (int i = 0; i < arr.length; i++){
                arr2[i] = arr[i];
            }
            arr2[arr2.length - 1] = num;
            arr = arr2;
            for (int i = 0; i < arr2.length; i++){
                System.out.print(arr2[i] + "\t");
            }
        } while(true);
        
    }
}

数组缩减

排序

冒泡排序：外层控制我们一共要比较多少轮，内层控制从第0个数开始，要比多少次

import java.util.Scanner;
public class Lianxi{
    public static void main(String[] args){
        int arr[] = {2, 10, 7, 5, 8, 6, 9};
        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];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        for(int i = 0; i < arr.length; i++){
            System.out.print(arr[i] + "\t");
        }
        
        
    }
}

查找

注意：有个小技巧，初始化index=-1来表示没有找到匹配的

import java.util.Scanner;
public class Lianxi{
    public static void main(String[] args){
        String[] names = {"hy", "lwj", "dxy", "tl", "zsq"};
        Scanner myScanner = new Scanner(System.in);
        System.out.println("请输入您要查找的字符串：");
        String name = myScanner.next();
        //技巧：index = -1 
        int index = -1;
        for (int i = 0; i < names.length; i++){
            if(name.equals(names[i])){
                index = i;
                System.out.println(name + "是第" + i +"个字符串");
            }
        }
        if(index == -1){
            System.out.println("没找到" + name);
        }
    }
}

二维数组

定义：原来每个一维数组的每个元素是一维数组，就构成二维数组

第一个表示二维数组里面有几个一维数组，第二个表示每个一维数组里面有几个元素

二维数组在内存里面的存在形式：

ok，现在打印出图片中的数组：

public class Lianxi{
    public static void main(String[] args){
        int[][] arr = new int[3][];//新建一个二维数组，有三个一维数组构成，但是每个一维数组没有开空间，指向的地址都是null
        for(int i = 0; i < arr.length; i++){
            arr[i] = new int[i + 1];//给每个一维数组单独开辟空间
            for(int j = 0; j < arr[i].length; j++){
                arr[i][j] = i + 1;
                System.out.print(arr[i][j] + " ");
            }
            System.out.println("");

        }

    }
}

静态初始化：

二维数组的应用

杨辉三角形

/*打印杨辉三角形
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
*/
//主要是三个规律把握住：
/*(1) 第i+1行有i个元素
  (2) 每行首末数字为1
  (3) yanghui[i][j] = yanghui[i - 1][j] + yanghui[i - 1][j - 1];
*/
public class Lianxi{
    public static void main(String[] args){
        int[][] yanghui = new int[10][];
        for(int i = 0; i < yanghui.length; i++){
            yanghui[i] = new int[i + 1];
            yanghui[i][0] = 1;
            yanghui[i][yanghui[i].length - 1] = 1;
            for(int j = 1; j < yanghui[i].length - 1; j++){
                yanghui[i][j] = yanghui[i - 1][j] + yanghui[i - 1][j - 1];
            }
        }
        for(int i = 0; i < yanghui.length; i++){
            for(int j = 0; j < yanghui[i].length; j++){
                System.out.print(yanghui[i][j]+" ");
            }
            System.out.println("");
        }
    }
}

本章练习题

1

我的思路：

先定位，再插入，

定位：采用index来定，这个和老师想得一样，但是遍历结束a， index=-1 之后，更为简洁的是，让index = a.length 表示插入的位置在最后一个。

插入：我的想法只用了一个下标，所以代码看着挺复杂的，没有老师的简洁。

import java.util.Scanner;
public class Lianxi{
    public static void main(String[] args){
        int[] a = {10, 12, 45, 99};
        int[] b = new int[a.length + 1];
        Scanner myScanner = new Scanner(System.in);
        System.out.println("请输入您要添加的数字");
        int num = myScanner.nextInt();
        int index = -1;
        for(int i = 0; i < b.length; i++){
            if(a[i] >= num){
                index = i;
                break;
            }
        }
        for(int i = 0; i < b.length - 1; i++){
            if (index == -1){
                b[i] = a[i];
                b[b.length - 1] = num;
            }else if (i < index){
                b[i] = a[i];
            }else if(i == index){
                b[i] = num;
                b[i + 1] = a[i];
            }else if( i > index){
                b[i + 1] = a[i];
            }
        }
        
        for(int i = 0; i < b.length; i++){
            System.out.print(b[i] + " ");
        }
    }
}

下面附上老师的思路：

用i表示新数组下标，j表示原来的数组下标，赋值的时候跳过index这个地方

import java.util.Scanner;
public class Lianxi{
    public static void main(String[] args){
        int[] a = {10, 12, 45, 99};
        int[] b = new int[a.length + 1];
        Scanner myScanner = new Scanner(System.in);
        System.out.println("请输入您要添加的数字");
        int num = myScanner.nextInt();
        int index = -1;
        for(int i = 0; i < b.length; i++){
            if(a[i] >= num){
                index = i;
                break;
            }
        }
        if (index == -1){
            index = a.length;
        }
        for(int i = 0, j = 0; i < b.length; i++){
            if(index != i){
                b[i] = a[j];
                j++;
            }else{
                b[i] = num;
            }
        }
        
        for(int i = 0; i < b.length; i++){
            System.out.print(b[i] + " ");
        }
    }
}
import java.util.Scanner;
public class Lianxi{
    public static void main(String[] args){
        int[] a = new int[10];
        for (int i = 0; i < a.length; i++){
            a[i] = (int)(Math.random()*100) + 1;
        }
        double sum = 0;
        int max = a[0];
        int maxIndex = -1;
        for(int i = a.length - 1; i >= 0; i --){
            System.out.print(a[i] + "\t");
            sum += a[i];
            if(max <= a[i]){
                max = a[i];
                maxIndex = i;
            }
            if(a[i] == 8){
                System.out.println(a[i] + "= 8");
            }
        }
        System.out.println("最大值为" + max + "，下标为" + maxIndex);
        System.out.println("平均值为" + sum/a.length);

    }
}

冒泡排序：

import java.util.Scanner;
public class Lianxi{
    public static void main(String[] args){
        int[] a ={3, 6, 1, 5, 2, 10, 9};
        int temp = 0;
        for (int i = 0; i < a.length - 1 ; i++){
            for (int j = 0; j < a.length - i - 1; j++){
                if(a[j] >= a[j + 1]){
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
        for(int i = 0; i < a.length; i++){
            System.out.print(a[i] + " ");
        }

    }
}
沙雕出现了
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值