java數組重復元素

『壹』 用java編寫 在兩個數組裡面 找出相同的元素 並輸出

有兩個數組，需要找出這兩個數組之間相同的元素。

package cn.luxh.jpa.test;import java.util.HashSet;import java.util.Set;import org.junit.Test;public class ArrayTest {

/**

* 找出兩個數組中相同的元素

* @param array1

* @param array2

* @return 返回相同的元素

*/

public Set<Integer> findSameElementIn2Arrays（Integer[] array1,Integer[] array2） {

Set<Integer> sameElementSet = new HashSet<Integer>（）；//用來存放兩個數組中相同的元素

Set<Integer> tempSet = new HashSet<Integer>（）；//用來存放數組1中的元素（廣州達內）

for（int i=0;i<array1.length;i++） {

tempSet.add（array1[i]）；//把數組1中的元素放到Set中，可以去除重復的元素

}

for（int j=0;j<array2.length;j++） {

//把數組2中的元素添加到tempSet中

//如果tempSet中已存在相同的元素，則tempSet.add（array2[j]）返回false

if（！tempSet.add（array2[j]）） {

//返回false,說明當前元素是兩個數組中相同的元

sameElementSet.add（array2[j]）；

}

}

return sameElementSet;

}

@Test

public void testFindSameElementIn2Arrays（）{

Integer[] array1 = {1,2,3,4,1,2,4,6,7,8,10,22,33};

Integer[] array2 = {1,2,3,4,1,2,4,6,7,8,10,22,33,55,66,77,88,99};

Set<Integer> sameElementSet = findSameElementIn2Arrays（array1,array2）；

for（Integer i : sameElementSet） {

System.out.println（i）；

}

}}

『貳』 java 判斷一個數組中是否有重復的元素

使用一個臨時list，藉助list.contains判斷當前數組的值是否存在於list中，如果不存在則加入到list中，如果存在則記錄出來。有點像把一個籃子中的撞球放到另一個空籃子中，如果籃子裡面已經有的就不要再放進去了，沒有的，一個個放進去。說到底就是個遍歷和存在性判斷問題。

『叄』 JAVA 遍歷數組，統計數組中包含幾個相同的元素

正則表達式： 不知道這樣算不算

int[] num={1,3,2,8,5,1,1,1};
String numstr = Arrays.toString(num);//把數組變成一個字元串[1, 3, 2, 8, 5, 5, 1, 1]
Pattern rex = Pattern.compile("1");//創建正則表達之對象匹配"1"
Matcher m = rex.matcher(numstr);// 匹配numstr字元串的匹配器
int count = 0;// 計數器，看匹配上了幾個
while(m.find()){ // find()方法從字元串中匹配"1" 找到返回true
count += 1; //找到1個 計數器值加 1
}
System.out.println(count);

『肆』 java怎麼判斷數組中有重復的元素

1、寫兩個for循環，外層for循環每取出一個值，都和內層for循環的值做比較，出現兩次及以上相同的情況，即有重復元素。當然這種效率比較低。
2、寫兩個for循環，外層for循環取第一個值的時候，和內層循環的第二個值及之後的值比較；外層for循環取第二個值的時候，和內層循環的第三個值及之後的值比較……
以此類推，出現一次及以上相同的情況，即有重復元素。
過程就是如此，代碼自己實現吧！

『伍』 java排序一個數組（數組元素有重復的）,並且記住新數組的元素在原數組中的位置，我需要能夠運行的程序！

public class ArrayTest {
public static void main(String[] args) {
//java排序一個數組（數組元素有重復的）,並且記住新數組的元素在原數組中的位置
int[] ary = {1,2,3,4,1,2};
int[] index = new int[ary.length];
for (int i = 0; i < index.length; i++) {
index[i] = i;
}
for (int i = 0; i < ary.length-1; i++) {
for (int j = i+1; j < ary.length; j++) {
if(ary[i]>ary[j]){
int temp = ary[i];
int p = index[i];
ary[i] = ary[j];
index[i] = index[j];
ary[j] = temp;
index[j] = p;
}
}
}
System.out.println(Arrays.toString(ary));
System.out.println(Arrays.toString(index));
}
}

『陸』 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如何將數組中具有相同的元素都刪去

如果是要把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數組中去掉重復數據可以使用set集合，set本身內部是不保存重復的數據的，如下代碼：

importjava.util.Arrays;
importjava.util.Set;
importjava.util.TreeSet;

publicclassceshi{
	publicstaticvoidmain(String[]args){

		int[]testArr={5,5,1,2,3,6,-7,8,6,45,5};//新建一個int類型數組
		System.out.println(Arrays.toString(testArr));
		Set<Integer>set=newTreeSet<Integer>();//新建一個set集合
		for(inti:testArr){
			set.add(i);
		}
		Integer[]arr2=set.toArray(newInteger[0]);
		//數組的包裝類型不能轉只能自己轉；吧Integer轉為為int數組；
		int[]result=newint[arr2.length];
		for(inti=0;i<result.length;i++){
			result[i]=arr2[i];
		}
		System.out.println(Arrays.toString(arr2));
	}
}

運行結果如下：

『玖』 java 返回數組連續重復元素的最大次數

你程序的邏輯是前後相等就加1，所以在在上面的1,1計數了1次，在中間4個3就是3次，加上最後的三個3是2次，結果當然就是6了。要改的話，前面的判斷沒啥必要可以去掉，改成

publicstaticintmaxNumRepeated(int[]a,intelem)
{
intcont=0;
intmaxNum=0;
for(inti=0;i<a.length;i++)
{
if(a[i]==elem)
{
cont++;
if(cont>maxNum)maxNum=cont;
}
elsecont=0;
}
returnmaxNum;
}

『拾』 java數組中的元素可以重復嗎

當然可以，全都一樣都行