java double数组去重
时间: 2023-11-17 20:01:44 浏览: 232
可以使用Set集合来去重,将double数组中的元素添加到Set集合中,由于Set集合不允许有重复元素,因此重复的元素会被自动去除。最后再将Set集合转换回数组即可。
```java
double[] arr = {1.2, 3.4, 5.6, 1.2, 7.8, 3.4};
Set<Double> set = new HashSet<>();
for (double d : arr) {
set.add(d);
}
double[] result = new double[set.size()];
int i = 0;
for (Double d : set) {
result[i++] = d;
}
```
相关问题
java数组用for循环去重
### 回答1:
可以使用双重循环来实现Java数组的去重,其中外层循环遍历数组中的每一个元素,内层循环则从当前元素的下一个位置开始遍历,如果找到了与当前元素相同的元素,则将该元素删除。具体实现可以参考以下代码:
```java
public static int[] removeDuplicates(int[] arr) {
int len = arr.length;
for (int i = 0; i < len; i++) {
for (int j = i + 1; j < len; j++) {
if (arr[i] == arr[j]) {
arr[j] = arr[len - 1]; // 将重复元素替换为数组末尾的元素
len--; // 数组长度减1
j--; // 内层循环变量j也要减1,以便检查替换后的新元素
}
}
}
// 创建一个新数组,将去重后的元素复制到新数组中
int[] newArr = new int[len];
System.arraycopy(arr, 0, newArr, 0, len);
return newArr;
}
```
这个方法可以处理任何类型的Java数组,包括int、double、String等。
### 回答2:
要用for循环对Java数组进行去重,可以按照以下步骤进行操作:
1. 创建一个新的空数组来存放去重后的元素。
2. 使用for循环遍历原数组中的每个元素。
3. 在循环中,使用一个flag变量来判断当前元素是否已经存在于新数组中。
4. 再次使用一个嵌套的for循环遍历新数组中的元素,与当前元素进行比较。
5. 如果找到相同的元素,则将flag设置为true,表示当前元素重复。
6. 如果在内部循环结束后,flag仍然为false,则表示当前元素是唯一的,可以将其添加到新数组中。
7. 最后,将新数组返回作为去重后的结果。
以下是一个简单的示例代码:
```java
public class ArrayDuplicateRemoval {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 2, 4, 3, 5};
int[] newArr = removeDuplicates(arr);
System.out.println("去重后的数组为:");
for (int i = 0; i < newArr.length; i++) {
System.out.print(newArr[i] + " ");
}
}
public static int[] removeDuplicates(int[] arr) {
int[] newArr = new int[arr.length];
int index = 0;
for (int i = 0; i < arr.length; i++) {
boolean flag = false;
for (int j = 0; j < index; j++) {
if (arr[i] == newArr[j]) {
flag = true;
break;
}
}
if (!flag) {
newArr[index++] = arr[i];
}
}
int[] result = new int[index];
System.arraycopy(newArr, 0, result, 0, index);
return result;
}
}
```
以上代码中,我们通过两次for循环来实现去重功能。时间复杂度为O(n^2),即需要遍历两次数组。最后将去重后的结果赋值给新的数组,并返回。
### 回答3:
java数组去重可以使用for循环来实现。可以使用两层for循环进行遍历,比较数组中的元素是否重复。首先,外层for循环遍历数组中的每一个元素,内层for循环则用来比较当前元素和后面的元素是否相等。如果相等,则使用数组的System.arraycopy()方法将后面的元素向前移动一位,从而实现去重。
以下是使用for循环实现数组去重的示例代码:
```java
public static void removeDuplicates(int[] arr) {
int len = arr.length;
int[] result = new int[len];
int k = 0;
for (int i = 0; i < len; i++) {
boolean isDuplicate = false;
// 检查当前元素是否在之前的元素中重复
for (int j = 0; j < i; j++) {
if (arr[i] == arr[j]) {
isDuplicate = true;
break;
}
}
// 如果不重复,则将当前元素添加到结果数组中
if (!isDuplicate) {
result[k++] = arr[i];
}
}
// 输出去重后的结果数组
for (int i = 0; i < k; i++) {
System.out.print(result[i] + " ");
}
}
public static void main(String[] args) {
int[] arr = {1, 3, 2, 2, 1, 5, 6, 4, 5};
removeDuplicates(arr);
}
```
以上代码中,首先定义了一个长度和原始数组相同的结果数组result,用来存放去重后的元素。然后使用外层for循环遍历数组中的每一个元素,内层for循环用来比较当前元素和之前的元素是否有重复。如果没有重复,则将当前元素添加到结果数组中。最后,使用for循环输出去重后的结果数组。
执行以上代码,输出结果为:1 3 2 5 6 4
java数组和集合都有哪些
### Java 中数组类型
Java中的数组用于存储固定数量的同类型元素。创建数组时,必须指定其长度以及所容纳元素的数据类型。数组分为一维数组和多维数组(如二维数组)。声明并初始化一个整数类型的数组如下所示:
```java
int[] numbers = {1, 2, 3};
```
对于二维或多维数组,则可以通过以下方式定义:
```java
int[][] matrix = {{1, 2}, {3, 4}};
```
一旦设定了数组大小,在程序运行期间无法改变这个尺寸。
### Java 集合框架包含的数据结构
#### List 接口及其实现类
`List` 是一种有序集合,允许重复项。常见的 `List` 实现有 `ArrayList`, `LinkedList` 等。这些实现了可变长特性,意味着可以在不预先知道确切容量的情况下向其中添加任意多个项目。
- **ArrayList**: 基于动态数组实现,支持随机访问操作。
```java
import java.util.ArrayList;
ArrayList<String> list = new ArrayList<>();
```
- **LinkedList**: 使用双向链表作为底层实现,适合频繁插入删除操作。
```java
import java.util.LinkedList;
LinkedList<Integer> linkedList = new LinkedList<>();
```
#### Set 接口及其子集
`Set` 不保存任何重复元素,并且没有固定的顺序。主要实现包括但不限于 `HashSet`, `LinkedHashSet`, 和 `TreeSet`.
- **HashSet**: 底层采用哈希表机制,提供快速查找性能[^5]。
```java
import java.util.HashSet;
HashSet<Double> hashSet = new HashSet<>();
```
- **LinkedHashSet**: 维护插入顺序的同时保持高效去重能力。
```java
import java.util.LinkedHashSet;
LinkedHashSet<Character> linkedHashSet = new LinkedHashSet<>();
```
- **TreeSet**: 自动按照自然排序或自定义比较器对元素进行升序排列。
```java
import java.util.TreeSet;
TreeSet<Long> treeSet = new TreeSet<>();
```
#### Map 接口及相关映射
`Map` 存储键值对(key-value pairs),不允许存在相同的键名。常用的几种形式为 `HashMap`, `LinkedHashMap`, 及 `TreeMap`.
- **HashMap**: 提供常量时间复杂度O(1)级别的存取效率.
```java
import java.util.HashMap;
HashMap<Float, String> hashMap = new HashMap<>();
```
- **LinkedHashMap**: 记录了迭代次序,默认按插入先后展示条目。
```java
import java.util.LinkedHashMap;
LinkedHashMap<Short, Boolean> linkedHashMap = new LinkedHashMap<>();
```
- **TreeMap**: 对记录按键自动排序,通常依据键的自然顺序或是构造函数提供的`Comparator`.
```java
import java.util.TreeMap;
TreeMap<Integer, Double> treeMap = new TreeMap<>();
```
阅读全文
相关推荐















