『壹』 求教java中Collections中sort泛型的問題。
就是你的List<T>這個T也就是你要放進去的類型，然後呢這個類型T要實現Comparable介面，這個介面有一個compareTo(T o)方法，你要重寫這個方法，在這個方法裡面寫你的排序規則。sort放回調用這個compareTo(T o)方法排序
舉個例子:一個User類
public class User implements Comparable{
private int age;
private String name;
//get set方法我就不寫了
//比較此對象與指定對象的順序。如果該對象小於、等於或大於指定對象，則分別返回負整 //數、零或正整數。
//這里我就用age比較
@Override
public int compareTo(T o){
User user=(User)o;
if(user!=null){
if(user.getAge()>this.getAge())
return 1;
else if(user.getAge()<this.getAge())
return -1;
else if(user.getAge()=this.getAge())
reutrn 0;
}
}
}
至於你問的那個是什麼意思，那個是泛型，可能你現在還不怎麼了解，學到後面就會知道了，有專門講這一章的
『貳』 求教java高手 關於TreeSet<E>泛型的排序問題
import java.util.TreeSet;
class Student implements Comparable<Student> {
private int english;
private String name;
public Student(int english, String name) {
this.english = english;
this.name = name;
}
public int getEnglish() {
return english;
}
public void setEnglish(int english) {
this.english = english;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int compareTo(Student s) {
if (english < s.getEnglish())
return 1;
if (english > s.getEnglish())
return -1;
return 0;
}
@Override
public String toString() {
return "name:" + this.name + " english:" + this.english;
}
}
public class Example7_13 {
public static void main(String args[]) {
TreeSet<Student> mytree = new TreeSet<Student>();
Student st1, st2, st3, st4, st5;
st1 = new Student(90, "zhan ying");
st2 = new Student(66, "wang heng");
st3 = new Student(86, "liu yifei");
st4 = new Student(90, "chan ying");
st5 = new Student(55, "zhan ying");
mytree.add(st1);
mytree.add(st2);
mytree.add(st3);
mytree.add(st4);
mytree.add(st5);
for (Student s : mytree) {
System.out.println(s);
}
}
}
『叄』 Java泛型方法題目
importjava.util.Arrays;
importjava.util.Collections;
importjava.util.List;
publicclassCollectionSort
{
publicstaticvoidmain(String[]args)
{
}
<Person>
{
privateStringname;
privateintage;
privateStringid;
publicStringgetName()
{
returnname;
}
publicvoidsetName(Stringname)
{
this.name=name;
}
publicintgetAge()
{
returnage;
}
publicvoidsetAge(intage)
{
this.age=age;
}
publicStringgetId()
{
returnid;
}
publicvoidsetId(Stringid)
{
this.id=id;
}
/**
*默認在這里進行排序
*/
publicintcompareTo(Personp)
{
//默認按照name進行排序
intresult=this.name.compareTo(p.getName());
if(this.name.equals(p.getName()))
{
//如果name一樣，那麼按照年年齡進行排序
result=this.age-p.getAge();
if(this.age==p.getAge())
{
//如果年齡也一樣，那麼按照id進行排序
result=this.id.compareTo(p.getId());
}
}
returnresult;
}
}
// 定義一個靜態方法
publicstatic<TextendsComparable<?>>voidsort(T[]dates)
{
Listl=Arrays.asList(dates);
Collections.sort(l);
}
// 對實現comparable介面的對象進行排序從小到大
// 自定義類，Person有屬性name,age,id
// 定義它的數組,進行排序
}
當然不使用person實現compare介面，使用匿名內部類做排序也可以。
『肆』 JAVA泛型類題目，請大神看看，有重賞！！
treemap只是根據map中的key的值來做排序的，在這里不知道你存儲的treemap的健值對是什麼，如果你要用treemap進行排行，那麼key必須是這些工人的年薪。此處建議不要用treemap排序，而改用arraylist存儲工人信息，用Collections.sort對這個list進行按年薪排序最好。
『伍』 java泛型完成數組問題，剛學泛型，求幫助
整數數組的順序收縮
public static int seqSearch(int[] arr, int first, int last, int target) {
for (int i = first; i < last; i++)
if (arr[i] == target)
return i;
return -1;
}
『陸』 java泛型
java泛型是1.5引進的一個新概念.
本題對於"? super T"和"? extends T",我從書上摘個經典的例子給你看看,如果不能理解,那麼你就參考以下書籍慢慢體會,循序漸進!
"? super T"和"? extends T",都是java泛型通配符,而用法又有區別,
還有super 和extends 不是java類關系中的超類和繼承的意思,他是通配符的下限和上限限制.
下面看一個通配符得高級用法:
在這一部分，我們來考慮一些通配符得高級用法。我們已經看到了上限通配符在從一個數據結構中進行讀取的幾個例子。現在考慮相反的情況，一個只寫的數據結構。
介面Sink是這種情況的一個簡單例子。
interface Sink<T> {
void flush(T t);
}
我們可以想像他被如下面的代碼一樣使用。方法writeAll() 被設計來把集合coll的所有元素flush到sink snk，並且返回最後一個flush的元素。
public static <T> T writeAll(Collection<T> coll, Sink<T> snk) {
T last = null;
for (T t : coll) {
last = t;
snk.flush(last);
}
return last;
}
Sink<Object> s;
Collection<String> cs;
String str = writeAll(cs, s); // 非法的調用!!
像上面所寫，writeAll() 的調用是非法的，因為沒有有效的類型參數可以被推斷出來。String 或 Object都不是T的合適的類型，因為Collection的元素和 Sink的元素必須是同樣的類型。
我們可以解決這個問題，通過使用通配符來修改writeAll()的方法簽名，如下：
<T> T writeAll(Collection<? extends T> coll, Sink<T> snk) { … }
String str = writeAll(cs, s); //可以調用但是返回值類型錯誤
這個調用現在是合法的，但是賦值產生錯誤，因為推斷出的返回值類型是 Object因為T 匹配了Sink的類型，Object。
解決方案是使用一種我們還沒有見過的有限制的通配符：有下限的通配符。語法 ? super T 表示T的一個未知的父類（或者是T自己）。這跟我們用? extends T 表示T的一個未知的子類是對應的。
<T> T writeAll(Collection<T> coll, Sink<? super T> snk) { … }
String str = writeAll(cs, s); // YES!!!
使用這個語法，這個調用是合法的，推斷出來的T是String，正是我們想要的。
現在讓我們看一個更現實的例子。一個 java.util.TreeSet<E> 代表一個有序的元素是E類型的樹。創建一個TreeSet的一個方法是傳遞一個 Comparator 對象給構造函數。這個Comparator將會用來按照需要對TreeSet進行排序。
TreeSet(Comparator<E> c)
Comparator 介面是核心：
interface Comparator<T> { int compare(T fst, T snd); }
假定我們要創建一個 TreeSet<String> 並傳遞一個合適的 Comparator，我們需要傳一個能比較String的Comparator。這可以是一個 Comparator<String>，也可以是一個 Comparator<Object>。然而我們不能用Comparator<Object>來調用上面的構造函數。我們可以使用一個有下限的通配符來得到我們需要的靈活性：
TreeSet(Comparator<? super E> c)
這允許任何可用的Comparator被傳遞進去。
作為使用下限通配符最終的例子，讓我們來看看方法 Collections.max()，它返回一個集合中的最大的元素。
現在，為了讓max()能工作，傳進來的集合中的所有元素必須實現 Comparatable介面。而且，他們必須都能夠被彼此比較（all be comparable to each other）。第一個嘗試是：
public static <T extends Comparable<T>> T max(Collection<T> coll)
就是說，方法的參數是某一個能和自己進行比較的T的集合。這限制太嚴格了。
為什麼？考慮一個能和任何對象進行比較的類型：
class Foo implements Comparable<Object> {...} ...
Collection<Foo> cf = ...;
Collections.max(cf); // 應該能工作
cf 中的每個元素都可以和每個cf中的其他元素進行比較，因為每個這樣的元素都是一個Foo,它可以和任意的對象進行比較，也可以和另一個Foo進行比較。
但是，使用上面的方法簽名，我們發現這個調用被拒絕。推斷出來的類型必須是Foo，但是Foo沒有實現介面 Comparable<Foo>。
T 精確的(exactly)和自己能比較是不需要的。所需要的是 T能夠和它的父類中的一個進行比較，這導出：（註：Collections.max()的實際方法簽名更復雜，我們在第10部分再討論。）
public static <T extends Comparable<? super T>> T max(Collection<T> coll)
這個推論對大多數想讓 Comparable 對任意類型生效的用法中都有效：你總是應該使用 Comparable<? super T>。
總之，如果你有一個只使用類型參數T作為參數的API，它的使用應該利用下限通配符( ? super T )的好處。相反的，如果API只返回T，你應該使用上限通配符( ? extends T )來給你的客戶端更大的靈活性。
（原文：This reasoning applies to almost any usage of Comparable that is intended to work for arbitrary types: You always want to use Comparable<? super T>.
In general, if you have an API that only uses a type parameter T as an argument, its uses should take advantage of lower bounded wildcards (? super T). Conversely, if the API only returns T, you'll give your clients more flexibility by using upper bounded wildcards (? extends T). ）。
如果你想比較深刻的了解java泛型那麼
建議你看看<Java1.5泛型指南>
中文鏈接地址:http://blog.csdn.net/explorers/archive/2005/08/15/454837.aspx#_Toc111865968
英文pdf格式地址:http://java.sun.com/j2se/1.5/pdf/generics-tutorial.pdf
『柒』 用泛型編寫一個冒泡排序法（java語言）
package com.xx.test;
public class BubbleSort<E> implements Comparable<E>{
public void bubbleSort(E[] array) {
// 聲明一個變數用於交換兩個元素時使用
E temp;
for(int i = 0; i < array.length - 1; i++) {
for(int j = 0; j < array.length - i - 1; j++) {
if(((Comparable<E>) array[j]).compareTo(array[j + 1]) < 0) {
temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
}
public int compareTo(E o) {
// 這里要實現比較兩個對象的大小
return 0;
}
}
因為是泛型，所以需要根據實際情況來寫一個compareTo方法來比較大小，例如傳進來的是基本數據類型，那麼就直接比較大小，如果傳進來的是字元串，按字典順序重寫compareTo()方法，其他的類型又怎麼比較就行了!