Value einer Hashtable nach deren grüße sortieren

Sorry habe was falsch geschrieben

Das ist dann mein Code:

import java.io.*;
import java.util.*;
import java.awt.*;
public class test {
public static void main(String[] args)throws IOException {
load();
}
public static void load(){
int nan = 3;
String seqe="ACGTAGATAGATCAGAT";
try {
System.out.println(seqe.length());
Hashtable map=new Hashtable();
for(int i=0;i<seqe.length()-nan+1;i++){

String seq = seqe.substring(i,i+nan);
Integer zahl=(Integer) map.get(seq);
if (zahl==null){
zahl=new Integer(1);
}//if
else{
zahl=new Integer(zahl.intValue()+1);
}//else

System.out.println(seq+" "+zahl);
map.put(seq,zahl);
}//for i
}//try
catch(Exception r) {
r.printStackTrace();
}
}
}

Er gibt das Ergebnis:

ACG 1
CGT 1
GTA 1
TAG 1
AGA 1
GAT 1
ATA 1
TAG 2
AGA 2
GAT 2
ATC 1
TCA 1
CAG 1
AGA 3
GAT 3

Was ich will jetzt machen sollte so aussehen:

AGA 3
GAT 3
TAG 2
AGA 2
GAT 2
ACG 1
CGT 1
GTA 1
TAG 1
AGA 1
GAT 1
ATA 1
ATC 1
TCA 1
CAG 1



Ich hoffe jetzt ist klar genug, Sorry noch mal wegen meinem deutsch, bin erste seit einem Jahr hier in Deutschland........
 
Vielleicht solltest du dir dazu noch eine neue HashTable erzeugen.
Die Alte kannst du dann durchlaufen, das höchste Element finden,
in die neue HashTable schreiben und in der alten löschen.
 
Entweder Du sortierst "per Schleife" selbst, oder nutzt der Einfachheit halber ein TreeSet:

Code: 
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
public class Haeufigkeit {
  
  private static final String SPLIT = " ";
  public static void main(String[] args) {
    Integer temp;
    String s = "ACGCTCGCTGATATAT";
    int x = 3;
    Map map = new HashMap();
    for (int i = 0; i < (s.length() - x); i++) {
      temp = (Integer)map.get(s.substring(i, i + x));
      if (temp == null) {
        map.put(s.substring(i, i + x), new Integer(1));
      } else {
        map.put(s.substring(i, i + x), new Integer(temp.intValue() + 1));
      }
    }
    Object key;
    Set set = new TreeSet(new Haeufigkeit().new MyComperator());
    for (Iterator it = map.keySet().iterator(); it.hasNext(); ) {
      key = it.next();
      set.add(key + Haeufigkeit.SPLIT + map.get(key));
    }
    for (Iterator it = set.iterator(); it.hasNext(); ) {
      key = it.next();
      System.out.println(key);
    }
  }
  
  // Vergleicher
  private class MyComperator implements Comparator {
    
    public int compare(Object o1, Object o2) {
      String[] s1 = ((String)o1).split(Haeufigkeit.SPLIT);
      String[] s2 = ((String)o2).split(Haeufigkeit.SPLIT);
      return this.compare(s1[0], s1[1], s2[0], s2[1]);
    }
    
    private int compare(String s11, String s12, String s21, String s22) {
      if (s12.equals(s22)) {
        return s11.compareTo(s21); // alphanumerischer Vergleich der Wortgruppen bei gleicher Häufigkeit
      } else {
        return s22.compareTo(s12); // alphanumerischer Vergleich der Häufigkeit (absteigend)
      }
    }
    
  }
}

Die Ausgabe ist dann:

HTML: 
ATA 2
CGC 2
GCT 2
ACG 1
CTC 1
CTG 1
GAT 1
TAT 1
TCG 1
TGA 1
 
Hallo!

ich haette das ungefaehr so gemacht:
Java: 
/**
 * 
 */
package de.tutorials;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.StringReader;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

/**
 * @author Tom
 * 
 */
public class DNAAnalysisExample {

    /**
     * @param args
     */
    public static void main(String[] args) throws Exception {
        String sequence = "ACGTAGATAGATCAGAT";

        System.out.println(new DNASequenceAnalyzer()
                .analyze(new BufferedReader(new StringReader(sequence))));

//        FileReader fileReader = new FileReader(new File("c:/dnaSequence.txt"));
//
//        System.out.println(new DNASequenceAnalyzer()
//                .analyze(new BufferedReader(fileReader)));
    }

    static class DNASequenceAnalyzer {
        Set<DNAPattern> analyze(BufferedReader sequenceReader) {
            Map<String, DNAPattern> results = new HashMap<String, DNAPattern>();
            DNASequenceIterator dnaSequenceIterator = new DNASequenceIterator(
                    sequenceReader, 3);
            while (dnaSequenceIterator.hasNext()) {
                String dnaSequenceKey = (String) dnaSequenceIterator.next();
                if (results.containsKey(dnaSequenceKey)) {
                    results.get(dnaSequenceKey).count++;
                } else {
                    results.put(dnaSequenceKey, new DNAPattern(dnaSequenceKey));
                }
            }
            return new TreeSet<DNAPattern>(results.values());
        }

        static class DNASequenceIterator implements Iterator {
            BufferedReader sequenceReader;

            StringBuilder nextSubSequence;

            char latestChar;

            boolean start;

            public DNASequenceIterator(BufferedReader sequenceReader,
                    int itemGauge) {
                this.sequenceReader = sequenceReader;
                this.nextSubSequence = new StringBuilder();
                char[] initialSubSequence = new char[itemGauge];
                try {
                    this.sequenceReader.read(initialSubSequence);
                    nextSubSequence.append(initialSubSequence);
                    start = true;
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }

            public boolean hasNext() {
                if (start) {
                    return true;
                } else {

                    int value;

                    try {
                        value = sequenceReader.read();
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }

                    if (value == -1) {
                        return false;
                    } else {
                        latestChar = (char) value;
                        return true;
                    }
                }
            }

            public Object next() {
                if (!start) {
                    nextSubSequence.deleteCharAt(0);
                    nextSubSequence.append(latestChar);
                } else {
                    start = false;
                }
                return nextSubSequence.toString();
            }

            public void remove() {
                throw new UnsupportedOperationException();
            }
        }

        /**
         * @author Tom
         * 
         */
        static class DNAPattern implements Comparable {
            String dnaPattern;

            int count;

            public DNAPattern(String dnaPattern) {
                this.dnaPattern = dnaPattern;
                this.count = 1;
            }

            public int hashCode() {
                return dnaPattern.hashCode();
            }

            public boolean equals(Object obj) {
                return dnaPattern.equals(obj);
            }

            public String toString() {
                return dnaPattern + ": " + count;
            }

            public int compareTo(Object o) {
                if (o instanceof DNAPattern) {
                    return this.count < ((DNAPattern) o).count ? 1 : -1;
                }
                return 0;
            }
        }
    }
}

So koennen auch etwas groessere Sequenzen als ein Zeichenstrom gesehen und analysiert werden.

Ausgabe:
[AGA: 3, GAT: 3, TAG: 2, ACG: 1, ATA: 1, ATC: 1, CGT: 1, GTA: 1, TCA: 1, CAG: 1]

Gruss Tom
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück