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;
}