菜鸟学Java 数组-上

本是古典何须时尚 2023-10-12 21:07 34阅读 0赞

#### 数组 ####

*   *  数组
     *   *  静态初始化数组
         *  字典、元组、集合
         *  数组的访问
     *  数组的遍历
     *   *  案例
     *  动态初始化数组
     *   *  案例

### 数组 ###

![在这里插入图片描述][46daa13ce20b47549bd4cce951f8fcba.png]

![在这里插入图片描述][df2896c982ca40a189325f2467ba4d65.png]  
数组比变量更加合适

#### 静态初始化数组 ####

定义数组的时候直接给数组赋值。  
静态初始化数组的格式:  
![在这里插入图片描述][89e7b14536f540eeb9a9f271c11c7e15.png]

package com.ithema.loop;
    
    import java.util.Arrays;
    
    public class demo251 {
        
        public static void main(String[] args) {
        
            int[] a = new int[] {
        1,2,3,4,5,6};
            double[] b = new double[] {
        1.1, 2.2, 3.3};
            String[] c = new String[] {
        "a1", "a2", "3a"};
    
            System.out.println(Arrays.toString(a));
            System.out.println(Arrays.toString(b));
            System.out.println(Arrays.toString(c));
    
            System.out.println("-------------------------------");
            int[] d = {
        1,2,3,4,7};
            double[] e = {
        11.1, 12.2, 13.3, 14.4};
            String[] f = {
        "aa", "bb", "cc"};
    
            System.out.println(Arrays.toString(d));
            System.out.println(Arrays.toString(e));
            System.out.println(Arrays.toString(f));
    
        }
    }

输出

[1, 2, 3, 4, 5, 6]
    [1.1, 2.2, 3.3]
    [a1, a2, 3a]
    -------------------------------
    [1, 2, 3, 4, 7]
    [11.1, 12.2, 13.3, 14.4]
    [aa, bb, cc]

> 为什么java 不能直接输出数组？

在Java中，无法直接使用`System.out.println()`函数来输出数组的内容，是因为数组在Java中被视为对象。当我们尝试输出一个数组时，实际上会调用数组的`toString()`方法来获取表示数组内容的字符串。

默认情况下，数组的`toString()`方法返回一个表示数组的内存地址的字符串，而不是数组元素的实际内容。这是因为`Java`中的数组是通过引用来传递的，而不是通过值来传递的。因此，直接输出数组会显示它的引用。

如果你想要输出数组的内容，可以使用`Arrays`类的静态方法`toString()`来将数组转换为字符串，然后再进行输出。例如：

int[] array = {
        1, 2, 3, 4, 5};
    System.out.println(Arrays.toString(array));

这将输出：`[1, 2, 3, 4, 5]`，显示数组的元素内容。

另外，你也可以使用循环遍历数组，并逐个输出数组的元素。这样可以更加灵活地控制输出的格式和方式。

int[] array = {
        1, 2, 3, 4, 5};
    for (int i = 0; i < array.length; i++) {
        
        System.out.println(array[i]);
    }

这将逐行输出数组的元素：

1
    2
    3
    4
    5

`Java`中无法直接输出数组的内容是因为数组被视为对象，而不是基本类型。要输出数组的内容，你可以使用`Arrays`类的`toString()`方法将数组转换为字符串，或者通过循环遍历数组逐个输出元素。

#### 字典、元组、集合 ####

> java中有没有类似python的字典、元组、集合这些概念？

是的，Java中也有类似于Python的字典、元组和集合的概念，尽管它们在使用方式和语法上可能略有不同。以下是Java中与这些概念对应的类和接口：

*  字典（Dictionary）：在Java中，与字典类似的概念是Map。Map是一个接口，它提供了键值对的映射关系。常见的Map实现类包括HashMap、TreeMap和LinkedHashMap。使用Map可以存储和检索基于键的值。当提到Java中的字典类似概念时，我们通常指的是Map接口及其实现类。Map接口定义了一种键值对映射的数据结构，其中键是唯一的，而值可以重复。以下是一个简单的示例，展示了如何使用Map接口及其实现类HashMap来创建、操作和访问字典（键值对）数据：

import java.util.HashMap;
    import java.util.Map;
    
    public class MapExample {
        
        public static void main(String[] args) {
        
            // 创建一个Map对象，使用HashMap实现
            Map<String, Integer> scores = new HashMap<>();
    
            // 添加键值对
            scores.put("Alice", 85);
            scores.put("Bob", 90);
            scores.put("Charlie", 95);
    
            // 获取键对应的值
            int aliceScore = scores.get("Alice");
            System.out.println("Alice's score: " + aliceScore);
    
            // 检查键是否存在
            boolean isBobPresent = scores.containsKey("Bob");
            System.out.println("Is Bob present? " + isBobPresent);
    
            // 修改键对应的值
            scores.put("Charlie", 100);
    
            // 遍历所有的键值对
            for (Map.Entry<String, Integer> entry : scores.entrySet()) {
        
                String name = entry.getKey();
                int score = entry.getValue();
                System.out.println(name + "'s score: " + score);
            }
    
            // 删除键值对
            scores.remove("Alice");
    
            // 判断Map是否为空
            boolean isEmpty = scores.isEmpty();
            System.out.println("Is the map empty? " + isEmpty);
        }
    }

上述示例中，我们使用HashMap作为Map接口的实现类。首先，我们创建一个scores的Map对象，它的键是String类型，值是Integer类型。然后，我们通过put()方法添加键值对，通过get()方法获取键对应的值，通过containsKey()方法检查键是否存在。我们还可以使用entrySet()方法遍历所有的键值对，通过remove()方法删除键值对，并通过isEmpty()方法检查Map是否为空。

运行上述示例，将会输出以下结果：

Alice's score: 85
    Is Bob present? true
    Alice's score: 85
    Charlie's score: 100
    Bob's score: 90
    Is the map empty? false

这个示例展示了使用Map接口的基本操作，你可以根据具体的需求和场景，使用Map接口及其不同的实现类来创建和操作字典数据结构。

*  元组（Tuple）：Java中没有内置的元组类型，但你可以通过创建自定义的类来模拟元组的行为。你可以创建一个简单的POJO（Plain Old Java Object）类，用于存储多个值，并提供相应的访问方法。

例如，假设你想创建一个包含姓名和年龄的元组，你可以创建一个名为Person的类，该类具有name和age属性以及相应的getter和setter方法。

public class Person {
        
        private String name;
        private int age;
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    }

然后，你可以创建Person对象，并设置和获取其属性：

Person person = new Person();
    person.setName("John");
    person.setAge(25);
    
    String name = person.getName();
    int age = person.getAge();

*  集合（Set）：在Java中，集合是一组唯一元素的容器。Java提供了多个实现Set接口的类，例如HashSet、TreeSet和LinkedHashSet。这些类提供了添加、删除和检查集合中元素的方法，并确保元素的唯一性。

例如，你可以创建一个包含整数的HashSet，并执行常见的集合操作：

Set<Integer> set = new HashSet<>();
    set.add(1);
    set.add(2);
    set.add(3);
    
    System.out.println(set); // 输出: [1, 2, 3]
    
    set.remove(2);
    
    System.out.println(set); // 输出: [1, 3]

需要注意的是，Java的集合和字典是泛型的，这意味着你可以在其中存储特定类型的元素。你可以指定集合或字典中元素的类型，并在使用时受益于类型安全和编译时检查。

![在这里插入图片描述][fdc48c5c03ed4911b67f87237902236a.png]

#### 数组的访问 ####

![在这里插入图片描述][d61c0c01072d419381ec3af3c82eb120.png]  
查看数组的长度-存储了多少个数据  
![在这里插入图片描述][345b3a91a16a48ee907eeb603381ff42.png]

package com.ithema.loop;
    
    import java.util.Arrays;
    
    public class demo251 {
        
        public static void main(String[] args) {
        
            int[] a  = {
        1,2,3};
    
            System.out.println(a[0]);
            System.out.println(a[2]);
            System.out.println(a[1]);
    
            a[0] = 100;
            System.out.println(Arrays.toString(a));
    
            System.out.println(a.length);
            
            int[] b = {
        };
            System.out.println(b.length);
    
        }
    }

输出

1
    3
    2
    [100, 2, 3]
    3
    0

> 如何将一个元素，加入已经定义好的数组，给出案例

在Java中，数组的长度是固定的，一旦创建后无法直接改变其大小。因此，无法直接将元素添加到已经定义好的数组中。但是，你可以创建一个新的数组，将原始数组的元素复制到新数组中，并在新数组的末尾添加新的元素。下面是一个示例：

import java.util.Arrays;
    
    public class AddElementToArrayExample {
        
        public static void main(String[] args) {
        
            // 原始数组
            int[] originalArray = {
        1, 2, 3, 4, 5};
    
            // 新元素
            int newElement = 6;
    
            // 创建新数组
            int[] newArray = new int[originalArray.length + 1];
    
            // 复制原始数组到新数组
            System.arraycopy(originalArray, 0, newArray, 0, originalArray.length);
    
            // 将新元素添加到新数组的末尾
            newArray[newArray.length - 1] = newElement;
    
            // 打印新数组
            System.out.println("Original array: " + Arrays.toString(originalArray));
            System.out.println("New array: " + Arrays.toString(newArray));
        }
    }

上述示例中，我们有一个已经定义好的原始数组originalArray，其中包含了一些元素。我们希望将新的元素newElement添加到该数组中。首先，我们创建了一个新的数组newArray，其长度比原始数组多1，以容纳新的元素。然后，我们使用System.arraycopy()方法将原始数组的元素复制到新数组中。最后，我们将新元素放入新数组的最后一个位置。最终，我们通过使用Arrays.toString()方法打印出原始数组和新数组的内容。

运行上述示例，将会输出以下结果：

Original array: [1, 2, 3, 4, 5]
    New array: [1, 2, 3, 4, 5, 6]

这样，我们成功将新的元素添加到已经定义好的数组中，并创建了一个新的包含所有元素的数组。请注意，原始数组本身并没有改变，而是创建了一个新的数组来存储扩展后的结果。

![在这里插入图片描述][d811b21e322f4df29004688c7e9bf283.png]

### 数组的遍历 ###

![在这里插入图片描述][2abd978604354234b96c23ed38eda69e.png]

> java中有没有类似python中的try except的用法？

在Java中，有类似于Python中的try-except的异常处理机制。Java使用try-catch块来捕获和处理异常。以下是一个示例：

public class ExceptionHandlingExample {
        
        public static void main(String[] args) {
        
            try {
        
                // 可能会引发异常的代码
                int result = divide(10, 0);
                System.out.println("Result: " + result);
            } catch (ArithmeticException e) {
        
                // 捕获并处理异常
                System.out.println("An arithmetic exception occurred: " + e.getMessage());
            }
        }
    
        public static int divide(int dividend, int divisor) {
        
            return dividend / divisor;
        }
    }

在上述示例中，我们定义了一个divide()方法，用于进行整数相除操作。在main()方法中，我们调用divide()方法并将其中一个操作数设置为0，这会导致ArithmeticException异常被抛出。为了捕获和处理这个异常，我们使用try-catch块。

在try块中，我们放置可能会引发异常的代码。在这个示例中，我们调用了divide()方法，并将结果存储在result变量中，并尝试打印出结果。由于除数为0，会触发ArithmeticException异常。

在catch块中，我们指定了要捕获的异常类型ArithmeticException。当异常被抛出时，程序会跳转到catch块，执行相应的处理逻辑。在这个示例中，我们打印出了异常的消息。

运行上述示例，将会输出以下结果：

An arithmetic exception occurred: / by zero

通过try-catch块，我们可以捕获和处理可能发生的异常，防止程序由于异常而崩溃，并采取适当的措施来处理异常情况。除了catch块，还可以使用finally块来执行无论是否发生异常都必须执行的代码。这样可以确保资源的释放和清理等操作得到正确处理。

接着说上面的遍历

快捷键：`a.fori + tab`

package com.ithema.loop;
    
    public class demo251 {
        
        public static void main(String[] args) {
        
            int[] a  = {
        1,2,3};
    
            for (int i = 0; i < a.length; i++) {
        
                System.out.println(a[i]);
            }
    
        }
    }

输出：

1
    2
    3

另一个更强方法

package com.ithema.loop;
    
    public class demo251 {
        
        public static void main(String[] args) {
        
            int[] a  = {
        1,2,3};
    
            for (int j : a) {
        
                System.out.println(j);
            }
    
        }
    }

#### 案例 ####

需求:某部门5名员工的销售额分别是: 16、26、36、6、100，请计算出他们部门的总销售额。

package com.ithema.loop;
    
    public class demo251 {
        
        public static void main(String[] args) {
        
            int[] a  = {
        16, 26, 36, 6, 100};
            int count = 0;
            for (int j : a){
        
                count += j;
            }
            System.out.println("总销售额为: "+count);
    
    
        }
    }

### 动态初始化数组 ###

![在这里插入图片描述][ca02cf18bd104cbb864e9537ca2a6fda.png]

> java数组有切片的思想吗？

在 Java 中，数组没有像 Python 中的切片（slicing）概念。在 Java 中，要获取数组的子数组或部分元素，你需要手动创建一个新的数组，并将所需的元素复制到新数组中。

下面是一个示例，展示了如何在 Java 中获取数组的子数组：

import java.util.Arrays;
    
    public class ArraySlicingExample {
        
        public static void main(String[] args) {
        
            int[] originalArray = {
        1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    
            int startIndex = 2;
            int endIndex = 7;
    
            int[] subArray = new int[endIndex - startIndex + 1];
    
            System.arraycopy(originalArray, startIndex, subArray, 0, subArray.length);
    
            System.out.println("Original array: " + Arrays.toString(originalArray));
            System.out.println("Subarray: " + Arrays.toString(subArray));
        }
    }

在上述示例中，我们有一个原始数组 originalArray，它包含了一些元素。我们想获取原始数组的子数组，从索引 startIndex 开始，到索引 endIndex 结束（包括两端的元素）。首先，我们计算子数组的长度，并使用 new 关键字创建一个新的 subArray 数组。然后，我们使用 System.arraycopy() 方法将原始数组的元素复制到子数组中。最后，我们使用 Arrays.toString() 方法打印原始数组和子数组的内容。

运行上述示例，将会输出以下结果：

Original array: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    Subarray: [3, 4, 5, 6, 7]

这样，我们手动获取了原始数组的子数组，并创建了一个新的包含所需元素的数组。

需要注意的是，Java 中的数组是固定长度的，无法直接进行切片操作。如果你需要频繁进行切片操作，可能需要考虑使用 ArrayList 等可变长度的集合类，或者编写自定义的工具方法来简化切片操作的过程。

先占位，再赋值

输出

[0, 0, 0]
    [0, 1, 2]

![在这里插入图片描述][f03df1de9eac4933974bb2dbbbbb8b1c.png]

package com.ithema.loop;
    
    import java.util.Arrays;
    
    public class demo251 {
        
        public static void main(String[] args) {
        
            int[] a = new int[3];
            System.out.println(Arrays.toString(a));
    
            char[] chars = new char[3];
            System.out.println((int) chars[0]);
    
            double[] dou = new double[3];
            System.out.println(dou[2]);
    
            boolean[] fal = new boolean[2];
            System.out.println(fal[1]);
    
            String[] str = new String[12];
            System.out.println(str[3]);
    
        }
    }

输出

[0, 0, 0]
    0
    0.0
    false
    null

![在这里插入图片描述][07496bbac7dc46bbabe7e6240dc57582.png]

#### 案例 ####

![在这里插入图片描述][80dae70a8b794271bba7b21652713904.png]

package com.ithema.loop;
    
    import java.util.Scanner;
    
    public class demo251 {
        
        public static void main(String[] args) {
        
            double[] score = new double[6];
            Scanner scanner =  new Scanner(System.in) ;
            for (int i = 0; i < score.length; i++) {
        
                System.out.println("请输入数字：");
                double data =  scanner.nextDouble();
                score[i] = data;
            }
            double sum = 0;
            for (double j : score){
        
                sum += j;
            }
            System.out.println(sum/score.length);
        }
    }

输出：

请输入数字：
    12
    请输入数字：
    13
    请输入数字：
    14.
    请输入数字：
    17.8
    请输入数字：
    13.
    请输入数字：
    25.
    15.799999999999999

当然这个程序，完全可以直接计算：

package com.ithema.loop;
    
    import java.util.Scanner;
    
    public class demo251 {
        
        public static void main(String[] args) {
        
            Scanner scanner = new Scanner(System.in);
            double avgdate = 0;
            for (int i = 0; i < 6; i++) {
        
                System.out.println("请输入数字：");
                double date = scanner.nextDouble();
                avgdate += date;
            }
            System.out.println(avgdate/6);
        }
    }

输出：

[46daa13ce20b47549bd4cce951f8fcba.png]: https://img-blog.csdnimg.cn/46daa13ce20b47549bd4cce951f8fcba.png
[df2896c982ca40a189325f2467ba4d65.png]: https://img-blog.csdnimg.cn/df2896c982ca40a189325f2467ba4d65.png
[89e7b14536f540eeb9a9f271c11c7e15.png]: https://img-blog.csdnimg.cn/89e7b14536f540eeb9a9f271c11c7e15.png
[fdc48c5c03ed4911b67f87237902236a.png]: https://img-blog.csdnimg.cn/fdc48c5c03ed4911b67f87237902236a.png
[d61c0c01072d419381ec3af3c82eb120.png]: https://img-blog.csdnimg.cn/d61c0c01072d419381ec3af3c82eb120.png
[345b3a91a16a48ee907eeb603381ff42.png]: https://img-blog.csdnimg.cn/345b3a91a16a48ee907eeb603381ff42.png
[d811b21e322f4df29004688c7e9bf283.png]: https://img-blog.csdnimg.cn/d811b21e322f4df29004688c7e9bf283.png
[2abd978604354234b96c23ed38eda69e.png]: https://img-blog.csdnimg.cn/2abd978604354234b96c23ed38eda69e.png
[ca02cf18bd104cbb864e9537ca2a6fda.png]: https://img-blog.csdnimg.cn/ca02cf18bd104cbb864e9537ca2a6fda.png
[f03df1de9eac4933974bb2dbbbbb8b1c.png]: https://img-blog.csdnimg.cn/f03df1de9eac4933974bb2dbbbbb8b1c.png
[07496bbac7dc46bbabe7e6240dc57582.png]: https://img-blog.csdnimg.cn/07496bbac7dc46bbabe7e6240dc57582.png
[80dae70a8b794271bba7b21652713904.png]: https://img-blog.csdnimg.cn/80dae70a8b794271bba7b21652713904.png