集合過濾重復項

㈠ 使用java集合去除一組數字中的重復項，並列印輸出

publicclassRemoveDuplicate{
	privatestaticint[]array={1,2,3,3,3,4,5,6,6,7};
	publicstaticvoidremove(){
		Set<Integer>set=newHashSet<>();
		for(inti:array){
			if(!set.add(i)){
				System.out.println(i);
			}
		}
		System.out.println(set.toString());
	}
	
	publicstaticvoidmain(String[]args){
		RemoveDuplicate.remove();
	}
}

以上是java代碼。可以利用set 的元素的唯一性來完成你的要求。

set.add() 方法 如果添加失敗那麼會返回false，也就意味著裡面已經有了一個同樣的元素。

當然這個方法未必是最好的。可以利用一些更巧妙的方法達成。那樣速度和效率都會更高。

(有部分人不知道為什麼我的代碼newHashSet<>裡面沒有指定類型。那麼請參考java1.7新特性)

㈡ Java中如何去除List中的重復的值

你要去除的值是基本數據類型還是對象呢？
如果不想存重復數據何不用Set呢。。。

其實吧。。在知道上提問不如在網頁上查。。這個是我查到的第一個。。網頁里的內容，他一共使用了3種方式
最近項目中需要對list集合中的重復值進行處理，大部分是採用兩種方法，一種是用遍歷list集合判斷後賦給另一個list集合，一種是用賦給set集合再返回給list集合。
但是賦給set集合後，由於set集合是無序的，原先的順序就打亂了。所以我又想著能不能用set的特性進行去重又不打亂順序呢？
試了一下，也是可以的，幾種方法在不同情況下都有各自的優勢。現在將代碼寫出來，比較一下。
//set集合去重，不打亂順序
public static void main(String[] args){
List<String> list = new ArrayList<String>();
list.add("aaa");
list.add("bbb");
list.add("aaa");
list.add("aba");
list.add("aaa");

Set set = new HashSet();
List newList = new ArrayList();
for (String cd:list) {
if(set.add(cd)){
newList.add(cd);
}
}
System.out.println( "去重後的集合： " + newList);
}123456789101112131415161718
//遍歷後判斷賦給另一個list集合
public static void main(String[] args){
List<String> list = new ArrayList<String>();
list.add("aaa");
list.add("bbb");
list.add("aaa");
list.add("aba");
list.add("aaa");

List<String> newList = new ArrayList<String>();
for (String cd:list) {
if(!newList.contains(cd)){
newList.add(cd);
}
}
System.out.println( "去重後的集合： " + newList);
}1234567891011121314151617
//set去重
public static void main(String[] args){
List<String> list = new ArrayList<String>();
list.add("aaa");
list.add("bbb");
list.add("aaa");
list.add("aba");
list.add("aaa");

Set set = new HashSet();
List newList = new ArrayList();
set.addAll(list);
newList.addAll(set);

System.out.println( "去重後的集合： " + newList);
}12345678910111213141516
//set去重(縮減為一行)
public static void main(String[] args){
List<String> list = new ArrayList<String>();
list.add("aaa");
list.add("bbb");
list.add("aaa");
list.add("aba");
list.add("aaa");

List newList = new ArrayList(new HashSet(list));

System.out.println( "去重後的集合： " + newList);
}12345678910111213

hashset不進行排序，還有一種方法是用treeset，去重並且按照自然順序排列，將hashset改為treeset就可以了。（原本的順序是改變的，只是按照字母表順序排列而已）
//去重並且按照自然順序排列
List newList = new ArrayList(new TreeSet(list));

㈢ 去除list集合中重復項的幾種方法

因為用到list，要去除重復數據，嘗試了幾種方法。記錄於此。。。

測試數據：

List<string> li1 = new List<string> { "8", "8", "9", "9" ,"0","9"};
List<string> li2 = new List<string> { "張三", "張三", "李四", "張三", "王五", "李四" };
List<string> li3 = new List<string> { "A", "A", "C", "A", "C", "D" };
List<string> li4 = new List<string> { "12", "18", "19", "19", "10", "19" };
方法一：

HashSet<string> hs = new HashSet<string>(li1); //此時已經去掉重復的數據保存在hashset中

方法二：

for (int i = 0; i < li2.Count; i++) //外循環是循環的次數
{
for (int j = li2.Count - 1 ; j > i; j--) //內循環是 外循環一次比較的次數
{

if (li2[i] == li2[j])
{
li2.RemoveAt(j);
}

}
}

方法三：

//把相同的用null代替。
for (int i = 0; i < li3.Count; i++)
{
for (int j = 0; j < li3.Count; j++)
{
if (i == j) continue;

if (li3[i] == li3[j])
{
li3[j] = "null";
}

}
}

方法四：

//這方法跟上面的一樣，只是變了邏輯
for (int i = 0; i < li4.Count - 1; i++)
{
for (int j = 0; j < li4.Count ; j++)
{
if (i != j)
{
if (li4[i] == li4[j])
{
li4[j] = "null";
}
}
}
}

最後輸出看結果

Console.WriteLine("li1去除重復後的值為");
hs.ToList().ForEach(item => Console.WriteLine(item));

Console.WriteLine("li2去除重復後的值為");
li2.ForEach(item => Console.WriteLine(item));

Console.WriteLine("li3去除重復後的值為");
li3.ForEach(item => Console.WriteLine(item));

Console.WriteLine("li4去除重復後的值為");
li4.ForEach(item => Console.WriteLine(item));

null我沒去掉。用的時候去掉即可。

當然。還有許多辦法。比如linq Distinct 等等都可以，看看網上的這個例子：去掉modelList中title重復的內容，不區分大小寫

class Program
{
static void Main(string[] args)
{
List<Model> modelList = new List<Model>()
{ new Model() { ID = 1, Title = "abcde" },
new Model() { ID = 2, Title = "ABCDE" },
new Model(){ ID = 3, Title = "AbcdE" },
new Model() { ID = 4, Title = "A" },
new Model() { ID = 5, Title = "a" }
};
Console.Read();
}
}
public class Model
{
public int ID { get; set; }
public string Title { get; set; }
}

解決方案一：這里比較的前提是對象的哈希代碼相等。否則不會比較，因為哈希代碼不相等。兩個對象顯然不相等

//定義一個類繼承IEqualityComparer介面
public class ModelComparer : IEqualityComparer<Model>
{
public bool Equals(Model x, Model y)
{
return x.Title.ToUpper() == y.Title.ToUpper();
}
public int GetHashCode(Model obj)
{
return obj.Title.ToUpper().GetHashCode();
}
}

調用：

modelList = modelList.Distinct(new ModelComparer()).ToList();

解決方案二：

var title = modelList.GroupBy(m => m.Title.ToLower().Trim()).Select(m => new { ID = m.FirstOrDefault().ID });
modelList = modelList.Where(m => title.Select(mo => mo.ID).Contains(m.ID)).ToList();
foreach (var item in modelList)
{
Console.WriteLine(item.ID + "\t" + item.Title);
}

當然。如果你僅僅比較兩個值是否相等。

List<string> li1 = new List<string> { "8", "8", "9", "8", "0", "9" };
li1 = li1.Distinct().ToList();

㈣ 關於List集合中用Set排除重復數據。

沒什麼問題

privatestaticSetgetList(SetstringList,Strings){
stringList.add(s);
returnstringList;
}

publicstaticvoidmain(String[]args){

SetmyList=newHashSet();
Strings1="aa";
Strings2="bb";
Strings3="cc";
Strings4="dd";
getList(myList,s1);
getList(myList,s2);
getList(myList,s3);
getList(myList,s4);
ListmyNeedList=newArrayList(myList);

}

㈤ 如何在List集合中排除重復的數據

它這個要求也就是讓最後輸出的結果為[a, c, d, f]，把出現一次以後的元素只剩下一個： for (int i = 0; i < list.size() - 1; i++) {//循環遍歷集體中的元素for (int j = list.size() - 1; j i; j--) {//這里非常巧妙，這里是倒序的是比較 if (list.get(j).equals(list.get(i))) { list.remove(j);}}} 因為這道題我們的思路是，先循環遍歷集合中的每一個元素，再依次用集合中的元素去比對後面的元素，如果有相同的，就在集合中把當前的元素移除掉，那麼，重點來了， 你移除了當前的集合，那麼

㈥ 如何在List集合中去除重復元素

1. 通過循環進行刪除
   
   public static void removeDuplicate(List list) {
   for ( int i = 0 ; i < list.size() - 1 ; i ++ ) {
   for ( int j = list.size() - 1 ; j > i; j -- ) {
   if (list.get(j).equals(list.get(i))) {
   list.remove(j);
   }
   }
   }
   System.out.println(list);
   }
   
   

2. 通過HashSet刪除
   public static void removeDuplicate(List list) {
   HashSet h = new HashSet(list);
   list.clear();
   list.addAll(h);
   System.out.println(list);
   }
   
   3、刪除重復元素，並保持順序。（我沒試）
   
   public static void removeDuplicateWithOrder(List list) {
   Set set = new HashSet();
   List newList = new ArrayList();
   for (Iterator iter = list.iterator(); iter.hasNext();) {
   Objectelement = iter.next();
   if (set.add(element))
   newList.add(element);
   }
   list.clear();
   list.addAll(newList);
   System.out.println( " remove plicate " + list);
   }
   
   4、定義一個方法，調用即可。
   
   publi List<String> getNewList(List<String> li){
   List<String> list = new ArrayList<String>();
   for(int i=0; i<li.size(); i++){
   String str = li.get(i); //獲取傳入集合對象的每一個元素
   if(!list.contains(str)){ //查看新集合中是否有指定的元素，如果沒有則加入
   list.add(str);
   }
   }
   return list; //返回集合
   }
   
   public class Test{
   public static void main(String[] args){
   ArrayList<String> arr = new ArrayList<String>();
   arr.add("aaa");
   arr.add("bbb");
   arr.add("aaa");
   arr.add("ccc");
   arr = getNewList(arr); //方法去重
   System.out.println(arr);
   }
   }

package com.test;

import java.util.*;public class Test { /**
AAAA AAAA BBBB BBBB CCCC CCCC CCCC CCCC */
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
list.add("AAAA");
list.add("AAAA");
list.add("AAAA");
list.add("BBBB");
list.add("BBBB");
list.add("BBBB");
list.add("CCCC");
list.add("CCCC");
list.add("CCCC");
list.add("DDDD"); new Test().removeDuplicateWithOrder(list);// System.out.println(list); } // 刪除ArrayList中重復元素
public static void removeDuplicate(List list) { for (int i = 0; i < list.size() - 1; i++) { for (int j = list.size() - 1; j > i; j--) { if (list.get(j).equals(list.get(i))) {
list.remove(j);
}
}
}
System.out.println(list);
} // 方法二：通過HashSet剔除 // 刪除ArrayList中重復元素,add進去順序就變了不考慮順序的話可以使用
public static void removeDuplicate1(List list) {
HashSet h = new HashSet(list);
list.clear();
list.addAll(h);
System.out.println(list);
} // 方法三： 刪除ArrayList中重復元素，保持順序 // 刪除ArrayList中重復元素，保持順序
public static void removeDuplicateWithOrder(List list) {
Set set = new HashSet();
List newList = new ArrayList(); for (Iterator iter = list.iterator(); iter.hasNext();) {
Object element = iter.next(); if (set.add(element))
newList.add(element);
}
list.clear();
list.addAll(newList);
System.out.println(" remove plicate " + list);
}
}

㈦ JAVA中，如何去掉LIST里的重復元素

最好的辦來法是用Set，因為Set裡面自存放的數據是不重復的。
如果你不想用Set，那還可以向下面這樣處理。

List list_tmp = new ArrayList(); //建立一個用於臨時存放不重復list元素的List集合。
for(Object obj:list){
//可以根據需要，在這里加上強制轉型。
//如list裡面存放的是一個User對象，那麼加上User u = (User) obj;
if(!list_tmp.contains(obj)){ //注意contains方法是通過equals方法進行比較的所以你要根據你自己的需要看是否需要重寫list對象裡面的equals方法。
list_tmp.add(obj);//如果上面加了強制轉型，這里需要寫list_tmp.add(u);
}
}

㈧ 關於List集合里去除一些重復項問題

class TT {
private int i;

public int getI() {
return i;
}

public void setI(int i) {
this.i = i;
}
TT(int i){
this.setI(i);
}
public boolean equals(Object obj) {
if(obj==null||!(obj instanceof TT))
return false;
return ((TT)obj).getI()==this.i;
}
}

list2 .removeAll(list1);

㈨ 如何去除List集合中重復的元素

1、通過循環進行刪除

public static void removeDuplicate(List list) {

for ( int i = 0 ; i < list.size() - 1 ; i ++ ) {

for ( int j = list.size() - 1 ; j > i; j -- ) {

if (list.get(j).equals(list.get(i))) {

list.remove(j);}}}

System.out.println(list);}

2、通過HashSet刪除

public static void removeDuplicate(List list) {

HashSet h = new HashSet(list);

list.clear();

list.addAll(h);

System.out.println(list);}

(9)集合過濾重復項擴展閱讀：

List集合代表一個元素有序，可重復的集合，集合中每個元素都有對應的順序索引。List介面中增加了一些根據索引操作元素的方法：

void add(int index,E element ) 在列表的指定位置插入該元素。

boolean addAll(int index,Collection c) 將集合c包含的所有元素都插入到List集合的index處。

Object get(int index) 返回集合index索引出的元素。

List額外提供的一個listIterator（）方法，提供了專門操作List的方法。

ListIterator介面在Iterator的基礎上增加了如下方法：

boolean hasPrevious(): 返回該迭代器關聯的集合是否還有上一個元素。

Object previous(): 返回該迭代器的上一個元素。

void add((E e): 在指定位置插入一個元素。