java数组去重

㈠ java去掉数组里的重复的数据

计数方法，你在遍历数组外边int 一个数=0，如果某个数和数组【i】相等，就++
删除方法我用的是笨方法，因为数组不能直接增删操作，要先算出新数组的长度，在遍历出去，我是取巧了先排序了，当然你也可以用其他排序方法排序
public static void main(String[] args) {
int [] arr={1,2,2,3,4,5};
int len=arr.length;
Arrays.sort(arr);
int leng=0;
for( int i=0;i<arr.length-1;i++){
if(arr[i]!=arr[i+1]){
leng++;
}
}
if(arr[arr.length-2]!=arr[arr.length-1]){
leng++;
}
System.out.println(leng);
int newlength=0;
int []newArr=new int[leng];
for( int i=0;i<arr.length-1;i++){
if(arr[i]!=arr[i+1]){
newArr[newlength]=arr[i];
newlength++;
}
}
if(arr[arr.length-2]!=arr[arr.length-1]){
newArr[newlength]=arr[arr.length-1];
}
for(int i=0;i<newArr.length;i++){
System.out.println(newArr[i]);
}

}

㈡ Java中的一维数组去掉当中的重复数据怎么操作

publicstaticvoidmain(String[]args){
int[]intArray=newint[]{6,2,9,6,1,2,6,7,8};
int[]noneRepeatArray=newint[]{};
for(inti:intArray){
booleanhasRepeat=false;
for(intj:noneRepeatArray){
if(i==j)hasRepeat=true;
}
if(!hasRepeat){
int[]tempArray=newint[noneRepeatArray.length+1];
System.array(noneRepeatArray,0,tempArray,0,noneRepeatArray.length);
noneRepeatArray=tempArray;
noneRepeatArray[noneRepeatArray.length-1]=i;
}
}
System.out.println(Arrays.toString(noneRepeatArray));
}

㈢ Java如何将数组中具有相同的元素都删去

如果是要把List中的重复元素删除的话可以先吧List转成Set去除重复元素

比如现在有个数组为 myArray ，里面有部分的重复元素

Set mySet = new HashSet();
for(Object obj : Array){
mySet.add(obj);
}

mySet中所保存的元素就是唯一的了.
再吧mySet保存到数组中

完整例子：
// 创建一个数组，里面存在重复的元素
String[] myArray = {"s","s","f","d"};
Set<String> mySet = new HashSet<String>();
// 去除重复元素
for(String s : myArray){
mySet.add(s);
}
myArray = new String[mySet.size()];
int index = 0;
// 将去重后的结果存入数组
for(String s : mySet){
myArray[index] = s;
index++;
}
// 打印出来结果
System.out.println(Arrays.toString(myArray));

㈣ JAVA关于顺序数组数据去重，效率最高的方式是什么

JAVA关于顺序数组数据去重，效率最高的方式是使用LinkedHashSet也是Set,set的特征就是对重复的元素只保存一个,LinkedHashSet只是在内部使用链表维护元素插入的顺序

packagecom.question;

importjava.io.BufferedReader;
importjava.io.FileInputStream;
importjava.io.FileNotFoundException;
importjava.io.FileOutputStream;
importjava.io.IOException;
importjava.io.InputStream;
importjava.io.InputStreamReader;
importjava.io.OutputStream;
importjava.util.LinkedHashSet;

/**
*deletetheconflictString.
*
*@authorXxx
*/
publicclassQ16{

/**
*generatethetext.
*
*/
publicvoidinit(){

//writefile
OutputStreamoutputStream=null;
try{
outputStream=newFileOutputStream("C:/init.txt");
for(inti=0;i<100000;i++){
for(intj=0;j<2;j++){
outputStream.write(("Hello"+i).getBytes());
outputStream.write("
".getBytes());
}
}
}catch(FileNotFoundExceptione){
e.printStackTrace();
}catch(IOExceptione){
e.printStackTrace();
}finally{
if(outputStream!=null){
outputStream=null;
}
}
}

/**
*filterthestring.
*
*@return
*/
publicLinkedHashSet<String>filter(){

//createaLinkedHashSetproject.
LinkedHashSet<String>linkedHashSet=newLinkedHashSet<String>();
try{

//readthefile.
InputStreaminputStream=newFileInputStream("C:/init.txt");
=newInputStreamReader(inputStream);
BufferedReaderbufferedReader=newBufferedReader(inputStreamReader);
Stringline=bufferedReader.readLine();

//
while(line!=null){
linkedHashSet.add(line);
line=bufferedReader.readLine();
}

}catch(FileNotFoundExceptione){
e.printStackTrace();
}catch(IOExceptione){
e.printStackTrace();
}
//returntheresult.
returnlinkedHashSet;
}

@Deprecated
publicstaticvoidmain(String[]args){
Q16q16=newQ16();
//q16.init();
LinkedHashSet<String>linkedHashSet=q16.filter();
System.out.println(linkedHashSet.size());
}
}

㈤ Java去除数组中的重复的数据后输出数组并把重复的数输出

就是再接一个新的list
你if{}后面加了else把重复数据添加到新list
然后遍历就可以了

㈥ java中怎么样子找出数组中重复的数，并去除

其实只要遍历数组，然后放进set集合内即可实现。
比如：
//set集合可以自动去重
Integer[] a = {1, 2, 2 , 19, 19, 8, 9};
Set<Integer> set = new HashSet<Integer>();
for(Integer i : a)
set.add(i);
for(Object s: set.toArray())
System.out.print(s+ " ");
}

㈦ java 数组如何去掉重复元素

理论上是可以的，但是太复杂了，借助于集合更好一些

㈧ java中怎么找出数组中重复的数并去除

java中找出数组中重复的数并去除的代码如下：

publicstaticvoidtestA(){
String[]str={"Java","C++","Php","C#","Python","C++","Java"};
for(StringelementA:str){
System.out.print(elementA+"");
}
List<String>list=newArrayList<String>();
for(inti=0;i<str.length;i++){
if(!list.contains(str[i])){
list.add(str[i]);
}
}
System.out.println();
String[]newStr=list.toArray(newString[1]);//返回一个包含所有对象的指定类型的数组
for(StringelementB:newStr){
System.out.print(elementB+"");
}
System.out.println();
}

㈨ 用Java删除数组中所有相同的数,使之仅剩下一个,然后输出剩下的数据

public class ArrayUnique {

/**
* 方法1 就是申请一个和nums大小一样的数组tmpNums，
* 然后遍历nums中的元素，对每个元素判断是否在tmpNums出现过，
* 如果出现过，那么就不放到新数组里面，也就是不做处理；
* 如果没有出现过，那么就把它放到新的数组里面
* 这种方法数组原来的相对顺序可以保证
* 时间复杂度是n^2和空间复杂度是n
*
*
@param nums 输入需要去重的数组
*
@return 返回去重后数组的长度

*/

public static int unique1(int[] nums) {

if (nums.length == 0) {

return 0;
}

int[] tmpNums = new int[nums.length];
tmpNums[
0] = nums[0];

int index = 1;

for (int i = 1, len = nums.length; i < len; i++) {

int j = 0;

for (; j < index; j++) {

if (tmpNums[j] == nums[i]) {

break;
}
}

if (j == index) {
tmpNums[index
++] = nums[i];
}
}
nums
= tmpNums;

return index;
}