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

数组

菜鸟学Java 数组-上_java

菜鸟学Java 数组-上_System_02

数组比变量更加合适

静态初始化数组

定义数组的时候直接给数组赋值。

静态初始化数组的格式:

菜鸟学Java 数组-上_开发语言_03

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.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.

输出

[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]
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.

为什么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.

这将输出：[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.

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

1
2
3
4
5
  • 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);
    }
}
  • 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.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.
  • 38.
  • 39.

上述示例中，我们使用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
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.

这个示例展示了使用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;
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.

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

Person person = new Person();
person.setName("John");
person.setAge(25);

String name = person.getName();
int age = person.getAge();
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 集合(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]
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.

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

菜鸟学Java 数组-上_数组_04

数组的访问

菜鸟学Java 数组-上_数组_05

查看数组的长度-存储了多少个数据

菜鸟学Java 数组-上_数组_06

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.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.

输出

1
3
2
[100, 2, 3]
3
0
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.

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

在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));
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.

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

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

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

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

菜鸟学Java 数组-上_开发语言_07

数组的遍历

菜鸟学Java 数组-上_jvm_08

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;
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.

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

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

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

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

An arithmetic exception occurred: / by zero
  • 1.

通过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.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.

输出：

1
2
3
  • 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);
        }

    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
案例

需求:某部门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);


    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.

动态初始化数组

菜鸟学Java 数组-上_jvm_09

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));
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.

在上述示例中，我们有一个原始数组 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]
  • 1.
  • 2.

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

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

先占位，再赋值

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));
        for (int i = 0; i < a.length; i++) {
            a[i] = i;
        }
        System.out.println(Arrays.toString(a));

    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.

输出

[0, 0, 0]
[0, 1, 2]
  • 1.
  • 2.

菜鸟学Java 数组-上_System_10

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]);

    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.

输出

[0, 0, 0]
0
0.0
false
null
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.

菜鸟学Java 数组-上_java_11

案例

菜鸟学Java 数组-上_System_12

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);
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.

输出：

请输入数字：
12
请输入数字：
13
请输入数字：
14.
请输入数字：
17.8
请输入数字：
13.
请输入数字：
25.
15.799999999999999
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.

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

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);
    }
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.

输出：

请输入数字：
12
请输入数字：
13
请输入数字：
14.
请输入数字：
17.8
请输入数字：
13.
请输入数字：
25.
15.799999999999999
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.