双层for循环排序，如何优化

0 0

双层for循环排序，如何优化0

class Cat
{
	private Integer id;
	private String title;
	
	public int hashCode()
	{
		final int prime = 31;
		int result = 1;
		result = prime * result + ((id == null) ? 0 : id.hashCode());
		return result;
	}
	public boolean equals(Object obj) 
	{
		if(getClass() != obj.getClass())
		{
			return false;
		}
		Cat other = (Cat)obj;
		return this.getId().equals(other.getId());
	}
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
}

现在有一个List<Cat> ，要对其排序
排序规则如下：
Integer[] sort_id = {18,2,3,5,7,30,1};
id在上面的数组中的话，就按照数组中的顺序排序，
不在数组中的，就无所谓了

我的写法如下：

public List<Cat> sort(List<Cat> cats)
	{
		List<Cat> result = new ArrayList<Cat>();
		
		Integer[] sort_id = {18,2,3,5,7,30,1};
		
		//先排序指定的
		for(Integer sid : sort_id)
		{
			for(Cat cat : cats)
			{
				if(sid.intValue() == cat.getId().intValue())
				{
					result.add(cat);
				}
			}
		}
		
		//把剩余的加入到result中
		for(Cat cat : cats)
		{
			if(!result.contains(cat))
			{
				result.add(cat);
			}
		}
		
		return result;
	}

这里用了双层for循环，请问，如何优化

排序双层for循环双层for循环排序

2014年9月01日 17:58

string2020
0
1 1 11

6个答案按时间排序按投票排序

0 0

/**
 *  现在有一个List<Cat> ，要对其排序
 排序规则如下：
 Integer[] sort_id = {18,2,3,5,7,30,1};
 id在上面的数组中的话，就按照数组中的顺序排序，
 不在数组中的，就无所谓了
 
 * 2014-9-3 下午1:51:58
 */
public class Main {


	public static void main(String[] args) {

		try {

			// 初始化数据
			List<Cat> list = new ArrayList<Cat>();
			for (int i = 1; i <= 30; i++) {
				Cat cat = new Cat();
				cat.setId(i);
				cat.setTitle("title " + i);
				list.add(cat);
			}

			// 指定排序条件
			Integer[] sortId = { 18, 2, 3, 5, 7, 30, 1 };
			
			Main mains = new Main();
			
			
			//方式一： list 转map 后 ，处理数据
			mains.prints(mains.sort01(list, sortId));
			
			//方式二： 前提，list中的索引 与 排序条件 相差1 并且 重写了 cat的equals方法, 思路：先获取sortId中对应的CatList，然后取差集，在取并集。
			mains.prints(mains.sort02(list, sortId));
			
			//方式三： 需要在 Cat类中加入 listIndex 字段，获取list时，初始化这个值. 同时这个值与 sortId联系在一起， 类似 方式二
			
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public List<Cat> sort02(List<Cat> list, Integer[] sortId) {
		
		//根据sortId排序
		List<Cat> result = new ArrayList<Cat>();
		for(Integer ints: sortId) {
			//获取 list中的索引：ints - 1
			result.add(list.get(ints - 1));
		}
		
		list.removeAll(result);
		
		//处理遗留的数据
		result.addAll(list);
		
		return result;
		
	}
	
	public List<Cat> sort01(List<Cat> list, Integer[] sortId) {
		
		//list to map
		Map<Integer, Cat> map = new HashMap<Integer, Cat>();
		for(Cat cat: list) {
			map.put(cat.getId(), cat);
		}
		
		//根据sortId排序
		List<Cat> result = new ArrayList<Cat>();
		for(Integer ints: sortId) {
			result.add(map.get(ints));
			
			map.remove(ints);
		}
		
		//处理遗留的数据
		for(Integer key: map.keySet()) {
			result.add(map.get(key));
		}
		
		return result;
		
	}
	
	
	private void prints(List<Cat> list) {
		for(Cat cat: list) {
			System.out.print("id:" + cat.getId() + ",title:" + cat.getTitle() + ";");
		}
		System.out.println();
	}

}

2014年9月03日 14:28

JavaStudyEye
1
0 0 3

5条评论

0 0

没有写注释，相信楼主能明白

public class C {

	
	
//	Integer[] sort_id = {18,2,3,5,7,30,1};
    public void sort(List<Cat> cats,Integer[]sort_id)  
    {  
        for(int i=0;i<cats.size();i++){
        	for(int j=0;j<sort_id.length;j++){
        		if(cats.get(i).getId().equals(sort_id[j])){
        			Cat temp = cats.get(j);
        			cats.set(j, cats.get(i));
        			cats.set(i, temp);
        		}
        	}
        }
    } 
    
    public static void main(String[] args) {
		C c  = new C();
		List<Cat> cats = new ArrayList<C.Cat>();
		for(int i=0;i<10;i++){
			Cat cat = c.new Cat();
			cat.setTitle("test");
			cat.setId(Integer.valueOf(i));
			cats.add(cat);
		}
		
		c.sort(cats, new Integer[]{3,5,2,9});
		System.out.println(cats);
	}
	
	
    class Cat  
    {  
        private Integer id;  
        private String title;  
          
        public int hashCode()  
        {  
            final int prime = 31;  
            int result = 1;  
            result = prime * result + ((id == null) ? 0 : id.hashCode());  
            return result;  
        }  
        @Override
		public String toString() {
			return "Cat [id=" + id + ", title=" + title + "]";
		}
		public boolean equals(Object obj)   
        {  
            if(getClass() != obj.getClass())  
            {  
                return false;  
            }  
            Cat other = (Cat)obj;  
            return this.getId().equals(other.getId());  
        }  
        public Integer getId() {  
            return id;  
        }  
        public void setId(Integer id) {  
            this.id = id;  
        }  
        public String getTitle() {  
            return title;  
        }  
        public void setTitle(String title) {  
            this.title = title;  
        }  
    }  
}

2014年9月03日 09:37

kidding87
1566
1 1 19

添加评论

0 0

Integer[] sort_id = {18,2,3,5,7,30,1};

        //先排序指定的
        for(Integer sid : sort_id)
        {
            for(Cat cat : cats)
            {
                if(sid.intValue() == cat.getId().intValue())
                {
                    result.add(cat);
                }
            }
        }
可以修改为：
         Integer[] sort_id = {18,2,3,5,7,30,1};
        //转换成字符串
        String strId=Arrays.toString(sort_id);
        for(Cat cat : cats)
            {
                if(cat.getId().indexOf(strId)!=-1)
                {
                    result.add(cat);
                }
            }
这样只有一个for循环，

2014年9月03日 09:16

斐斐宝贝
327
0 1 6

添加评论

0 0

不清楚下面的改动行不行

//先排序指定的
        for(Integer sid : sort_id)
        {
            for(Cat cat : cats)
            {
                if(sid.intValue() == cat.getId().intValue())
                {
                    result.add(cat);
                }
            }
        }
        cats.removeAll(result);
        result.addAll(result.size()-1, cats);

2014年9月02日 11:17