数组
数组比变量更加合适
静态初始化数组
定义数组的时候直接给数组赋值。
静态初始化数组的格式:
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的集合和字典是泛型的，这意味着你可以在其中存储特定类型的元素。你可以指定集合或字典中元素的类型，并在使用时受益于类型安全和编译时检查。
数组的访问
查看数组的长度-存储了多少个数据
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]
这样，我们成功将新的元素添加到已经定义好的数组中，并创建了一个新的包含所有元素的数组。请注意，原始数组本身并没有改变，而是创建了一个新的数组来存储扩展后的结果。
数组的遍历
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);
}
}
动态初始化数组
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 等可变长度的集合类，或者编写自定义的工具方法来简化切片操作的过程。
先占位，再赋值
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));
}
}
输出
[0, 0, 0]
[0, 1, 2]
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
案例
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);
}
}
输出：
请输入数字：
12
请输入数字：
13
请输入数字：
14.
请输入数字：
17.8
请输入数字：
13.
请输入数字：
25.
15.799999999999999