Возвращение общего типа в Java Hashtables

Question

В настоящее время мы изучаем хэш-таблицы в нашем курсе Java.

Лектор изложил несколько методов для нас. Первые два хороши, но я борюсь с «public E max()». Большинство материалов, которые я прочитал, похоже, указывают на то, что вы не можете создавать типичный тип, поэтому я изо всех сил пытаюсь понять, как я могу написать этот метод для хэш-таблицы.

Целью является, конечно, вернуть наибольшее значение в хэш-таблицу, что, я думаю, я мог бы сделать, если тип не был общим, но в этом случае он есть.

Извините, если мой код немного трудно читать.

import java.lang.reflect.Array; 
import java.util.*; 

public class Assignment6_2015 { 
public static void main(String[] args){ 

//======================================================= 
// Question 1, test Point class by creating a hashlist of Point instances  

    HashList<Point> h1 = new HashList<Point>(5); 
    h1.add(new Point(1,2)); 
    h1.add(new Point(2,4)); 
    h1.add(new Point(2,4)); 
    h1.add(new Point(2,4)); 
    h1.add(new Point(3,8)); 
    h1.add(new Point(3,8)); 
    h1.add(new Point(7,3)); 
    h1.add(new Point(9,10)); 
    h1.add(new Point(9,10)); 
    h1.add(new Point(9,10)); 
    h1.add(new Point(9,10)); 
    h1.add(new Point(9,10)); 
    h1.displayLists(); 

//======================================================= 
// Question 2, testing new methods 

    // ----- Frequency Method Test ----- 
    System.out.println(); 
    System.out.print("Frequency of Points (9,10): "); 
    System.out.println(h1.freq(new Point(9,10))); 

    System.out.println(); 
    System.out.print("Frequency of Points (2,4): "); 
    System.out.println(h1.freq(new Point(2,4))); 

    System.out.println(); 
    System.out.print("Frequency of Points (1,2): "); 
    System.out.println(h1.freq(new Point(1,2))); 
    // ----- End Frequency Method Test ----- 

    System.out.println(); 
    System.out.print("Table Size: "); 
    System.out.println(h1.tableSize()); 
    System.out.print("All used?: "); 
    System.out.println(h1.allUsed()); 
    System.out.print("Percentage used?: "); 
    System.out.println(h1.percentUsed()); 
    } 
    } 

    //======================================================= 
    // class Point 
    class Point implements Comparable<Point>{ 
    private int x,y; 
    Point(int a, int b){x = a; y = b;} 
    public int x(){return x;} 
    public int y(){return y;} 
    public String toString(){return "("+x+","+y+")";} 

    public boolean equals(Object ob){ 
    Point p = (Point)ob; 
    if(x == p.x() && y == p.y()){ 
     return true; 
    } 
    else{ 
     return false; 
    } 
} 

public int compareTo(Point p){ 
    if(x > p.x() && y > p.y()){ 
     return 0; 
    } 
    else{ 
     return -1; 
    } 
} 

public int hashCode(){ 
    return x*y*31; 
    } 
} 
    //End class Point 
    //======================================================= 
    //HashTable class 
    class HashList<E extends Comparable<E>>{ 
    private GLinkedList<E> data[]; 
    public HashList(int n){ 
    data = (GLinkedList<E>[])(new GLinkedList[n]); 
    for(int j = 0; j < data.length;j++) 
     data[j] = new GLinkedList<E>(); 
} 
private int hashC(E x){ 
    int k = x.hashCode(); 
    //an alternative is to mask the minus using 
    //int k = x.hashCode() & 0x7fffffff; 

    int h = Math.abs(k % data.length); 
    return(h); 
} 

public void add(E x){ 
    int index = hashC(x); 
    data[index].add(x); 
} 

public boolean contains(E x){ 
    int index = hashC(x); 
    return(data[index].contains(x)); 
} 
public void displayLists(){ 
    for(GLinkedList<E> k : data){ 
    if(k.length() > 0) 
      k.display(); 
    } 
} 
public void display(){ 
    System.out.print("<"); 
    int ind = 0; 
    while(ind < data.length){ 
     Iterator<E> it = data[ind].iterator(); 
     while(it.hasNext()) 
      System.out.print(it.next()+" "); 
     ind++; 
    } 
    System.out.println(">"); 
} 
public int tableSize(){ 
    return data.length; 
} 
//=================================================================== 
//Add new methods for assignment here 

public int freq(E x){ 
    int freq = 0; 
    int index = hashC(x); 
    for(int j = 0; j < data[index].length();j++){ 
     if(data[index].contains(x)){ 
      freq++; 
     } 
    } 
     return freq; 
} 

public boolean allUsed(){ 
    int total = data.length; 
    int inuse = 0; 
    for(int j = 0; j < data.length;j++){ 
     if(data[j].length() >= 1){ 
      inuse++; 
     } 
    } 

    if(inuse == total){return true;} 
    else{return false;} 
} 

public E max(){ 
    int j = 0; 
    E y = // ???; 
    Iterator<E> it = data[j].iterator(); 
     while(j<data.length){ 
      it = data[j].iterator(); 
      E x = it.next(); 
      while(it.hasNext()){ 
       if(data[j].iterator().next().compareTo(x) == 0){ 
        x = it.next(); 
        y = x; 
       } 
      } 
     j++; 
     } 
    return y; 
} 

//int x = (it.next().compareTo(largest)); 
//if(x == 0){largest = it.next();} 




//==================================================================== 
public double percentUsed(){ 
    int count = 0; 
    for(int j = 0; j < data.length; j++){ 
     if(data[j].length() > 0) 
      count++; 
    } 
    double p = count *100.0/data.length; 
    return p; 
} 
public int largestBucket(){ 
    int max = 0; 
    for(int j = 0; j < data.length; j++) 
     if(data[j].length() > max) max = data[j].length(); 
    return max; 
} 
public int smallestBucket(){ 
    int min = data[0].length(); 
    for(int j = 1; j < data.length; j++) 
     if(data[j].length() < min) min = data[j].length(); 
    return min; 
} 
public int[] listSizes(){ 
    int n = this.largestBucket(); 
    int d[] = new int[n+1]; 
    for(int j = 0; j < d.length; j++) d[j] = 0; 
    for(int j = 0; j < data.length; j++){ 
     int m = data[j].length(); 
     d[m] = d[m] + 1; 
    } 
    return d; 
} 
public int empty(){ 
    int count = 0; 
    for(int j = 0; j < data.length; j++) 
     if(data[j].length() == 0) count++; 
    return count; 
} 
public Iterator<E> iterator(){ 
    ArrayList<E> items = new ArrayList<E>(); 
    int ind = 0; 
    while(ind < data.length){ 
     Iterator<E> it = data[ind].iterator(); 
     while(it.hasNext()) 
      items.add(it.next()); 
     ind++; 
    } 
    return items.iterator(); 
} 
} 
class GLinkedList<E extends Comparable<E>>{ 
private Node<E> head = null;//empty list 
private int size = 0; 
public void add(E x){ //add at head 
    Node<E> nw = new Node<E>(x); 
    nw.setNext(head); 
    head = nw; 
    size++; 
} 

public boolean contains(E x){ 
    Node<E> k = head; 
    boolean found = false; 
    while(k != null && !found){ 
     E kk = k.data(); 
     if(kk.compareTo(x) == 0) found = true; 
     else k = k.next(); 
    } 
    return found; 
} 

public void remove(E x){ 
    Node<E> k = head; Node<E> bk = head; 
    boolean found = false; 
    while(k != null && !found){ 
     if(k.data().compareTo(x) == 0) found = true; 
     else{ bk = k; k = k.next();} 
    } 
    if(found) 
     if(k == head) 
      head = k.next(); 
     else 
      bk.setNext(k.next()); 
} 

public int length(){ 
    return size; 
} 
public void display(){ 
    Node<E> k = head; 
    System.out.print('['); 
    while(k != null){ 
     if(k.next != null) 
      System.out.print(k.data()+", "); 
     else 
      System.out.print(k.data()); 
     k = k.next(); 
    } 
    System.out.println(']'); 
} 
public Iterator<E> iterator(){ 
    return new GIterator<E>(head, size); 
} 
    private static class GIterator<E extends Comparable<E>> implements Iterator<E>{ 
    private Node <E> head; 
    private int size; 
    private int index = 0; 
    GIterator(Node<E> h, int s){ 
     head = h; size = s; 
    } 
    public boolean hasNext(){ 
     return index < size; 
    } 
    public E next(){ 
     if(index == size) throw new NoSuchElementException(); 
     E item = head.data(); 
     head = head.next(); index++; 
     return item; 
    } 
    public void remove(){} 
} 
} 
class Node<E extends Comparable<E>>{ 
E data; 
Node<E> next; 
public Node(E x){ 
    data = x; next = null; 
} 
public Node<E> next(){return next;} 
public void setNext(Node<E> p){ 
    next = p; 
} 
public void set(E x){data = x;} 
public E data(){return data;} 
} 

В настоящее время на данный момент, метод не более() не работает, я попробовал несколько вещей в нем, но я не могу показаться, чтобы не возвращать общего типа, независимо от того, каким образом Я подхожу к нему.

Answer 1

Почему бы тебе не написать это

E y=null; 

Answer 2

Чтобы очистить свой код немного, помогают уменьшить сложность и избежать ошибок, вы могли бы использовать этот фрагмент кода для перебора всех элементов

for (GLinkedList<E> d : data) { 
    final Iterator<E> it = d.iterator(); 
    while (it.hasNext()) { 
    final E currentElement = it.next(); 

    // Insert logic here! 

    } 
} 

Answer 3

Класс Point реализует Comparable, и поскольку HashList состоит из объектов Comparable, вы можете использовать это свойство для сравнения: Point рассматривается как Comparable.

Логика max() это что-то вроде:

declare max as a `Comparable` 
for each linked-list `ll` in `data` 
    for each element `c` in `ll` 
     if `c.compareTo(max) >= 0` then 
     max <- c 
     endif 
    endfor 
endfor 
return max 

Вы должны обращаться с max инициализации либо null или к первой точке в hashlist, или в какой-то точке значение, которое будет всегда уступает к любой момент, например Point(Integer.MIN_VALUE, Integer.MIN_VALUE).

Answer 4

Вы можете изменить эти две строки в максимальном способе таким образом, следующим образом:

E y = (E)data[0]; // ???; 
int j = 1; 

Над изменением кода будет решить вашу проблему. Также вы должны указать другие нулевые проверки и т. Д., Которые упомянуты выше в комментариях.

if(y==null) return null; //since there is no element in the array