addinional java

java help

================ some work with containers on specific container....

public class CountryUnionImpl implements CountryUnion {
    
    private Set<Country> countries = new HashSet<Country>();

    public boolean add(Country country) {
        if (country == null) return false;
        if (countries.contains(country)) return false;
        return countries.add(country);
    }
    
    public boolean remove(Country country) {
        if (country == null) return false;
        return countries.remove(country);
    }

    public int getPopulation() {
        int result = 0;
        for (Iterator it = countries.iterator(); it.hasNext(); ) {
            Country c = (Country) it.next();
                result += c.getPopulation();
        }
        return result;
    }
    
    public Collection<Country> getCountries() {
       return Collections.unmodifiableSet(countries);
    }
    
    public String toString() {
        return countries.toString();
    }
}

====================================== more helpfull maybe from here

public class MapPolygon implements GraphicObject
{   
    private SortedMap<String, Point> vertices = new TreeMap<String,Point>();
    
    public boolean addVertex(String name, Point p) {
        if (name == null || p == null) return false;
        if (name.length() != 1) return false;
        if (vertices.containsKey(name)) return false;
        vertices.put(name, p);
        return true;
    }
    
    public Point getVertex(String name) {
        return vertices.get(name);
    }
    
    public Set<String> getVertex(Point p) {
        Set<String> ret = new HashSet<String>();
        for (String name : vertices.keySet()) {
            if (vertices.get(name).equals(p)) ret.add(name);
        }
        return ret;
    }
    
    @Override
    public String toString() {
        return vertices.toString();
    }   
    
    public double getPerimeter() {
        double ret = 0.0;
        
        Point prev = null;
        
        for (Point act : vertices.values()) {
            if (prev == null) {
                prev = act;
                continue;
            }
            ret += prev.dist(act);
            prev = act;
        }
        
        ret += prev.dist(vertices.get(vertices.firstKey()));
        
        return ret;
    }  
    
    public SortedSet<Point> getSortedPoints() {
        return new TreeSet<Point>(vertices.values());
    }
    
    public SortedSet<Point> getSortedPoints(Comparator<Point> comp) {
        SortedSet<Point> ret = new TreeSet<Point>(comp);        
        ret.addAll(vertices.values());
        return ret;
    }
    
    public boolean equals(Object obj) {
        if (!(obj instanceof MapPolygon)) return false;
        return ((MapPolygon)obj).vertices.equals(this.vertices);
    }
    
    public int hashCode() {
        return vertices.hashCode();
    }


========= in here there is a little somtehnig with input/output
    
    public void write(OutputStream out) throws IOException {
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(out));
        
        for (String name : vertices.keySet()) {
            writer.write(vertices.get(name).getX());
            writer.write(" ");
            writer.write(vertices.get(name).getY());
            writer.write("");
            writer.write(name);
            writer.newLine();
        }
        
        writer.flush();
    }
    
    public void write(String file) throws IOException {
        write(new File(file));
    }

    public void write(File file) throws IOException {
        FileOutputStream out = new FileOutputStream(file);
        try {
            write(out);
        }
        finally {
            out.close();
        }
    }
    
    public void write() throws IOException {
        write(System.out);
    }
    
    public void read(File file) throws IOException {
        BufferedReader reader = new BufferedReader(new FileReader(file));
        
        String line = reader.readLine();
        while (line != null) {
            String[] ss = line.split("", 3); // pozri si StringBuilder
       
            if (ss.length != 3) throw new IOException("Wrong data format");
            try {
                int x = Integer.parseInt(ss[0]);
                int y = Integer.parseInt(ss[1]);
                
                vertices.put(ss[2], new Point(x,y));
            } catch(NumberFormatException ex) {
                throw new IOException("wrong format of data", ex);
            }
            
            
            line = reader.readLine();
        }
    }
}

================================= aaaaaaaaaaaaaaaand this one here with list

public class ListPolygon implements GraphicObject
{
    private List<Point> vertices;
    
    public ListPolygon(List<Point> vertices) {
        if (vertices == null) throw new NullPointerException("vertices");
        if (vertices.contains(null)) throw new NullPointerException("vertices");
        this.vertices = new ArrayList<Point>(vertices);
        //this.vertices.addAll(vertices);
    }
    
    /**
     * @return false if p is null, true otherwise
     */
    public boolean addPoint(Point p) {
        if (p == null) return false;
        return vertices.add(p);
    }
    
    /**
     * @return number of really removed vertices
     */
    public int removePoints(int from, int to) {
        int ff = from;
        int tt = to;
        if (from > to) {
            ff = to;
            tt = from;
        }
        if (ff < 0) ff = 0;
        if (tt >= vertices.size()) tt = vertices.size() - 1;
        
        List<Point> aux = new ArrayList<Point>();
        for (int i = ff; i <= tt; i++) {
            aux.add(vertices.get(i));
        }
        vertices.removeAll(aux);
        
        return tt-ff+1;
    }
    
    public List<Point> getVertices() {
        return Collections.unmodifiableList(vertices);
        //return new ArraList<Point>(vertices);
    }
    
    public ListPolygon cut(int maxX) {
        List<Point> aux = new ArrayList<Point>();
        for (Point p: vertices) {
            if (p.getX() <= maxX) aux.add(p);
        }
        return new ListPolygon(aux);
    }
    
    public void cutMe1(int maxX) {
        for (int i = 0; i < vertices.size(); i++) {
            if (vertices.get(i).getX() > maxX) {
                vertices.remove(i);
                i--;
            }
        }
    }

    public void cutMe2(int maxX) {
        List<Point> aux = new ArrayList<Point>();
        for (Point p: vertices) {
            if (p.getX() <= maxX) {
                aux.add(p);
            }
        }
        vertices = aux;
        //vertices.removeAll(aux);
    }
    
    public void cutMe3(int maxX) {
        for (Iterator<Point> it = vertices.iterator(); it.hasNext(); ) {
            Point p = it.next();
            if (p.getX() > maxX) it.remove();                
        }
    }
    
    public boolean equals(Object obj) {
        if (!(obj instanceof ListPolygon)) return false;
        //ListPolygon p = (ListPolygon) obj;
        return ((ListPolygon)obj).vertices.equals(this.vertices);
    }
    
    public int hashCode() {
        return vertices.hashCode();
    }
    
    public double getPerimeter() {
        double ret = 0.0;
        for (int i = 0; i < vertices.size(); i++) {
            ret += vertices.get(i).dist(vertices.get((i+1)%vertices.size()));
        }
        return ret;
    }  
}

===================== belongs to the first one with the Map === >

public class Point implements Comparable<Point> {

    private int x;
    private int y;
    
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
    
    public String toString() {
        return "[" + x + ", " + y + "]";
    }
    
    public int getX() {
        return x;
    }
    
    public int getY() {
        return y;
    }
    
    public double dist(Point p) { 
        if (p == null) return -1.0;
        int dx = this.getX() - p.getX();
        int dy = this.getY() - p.getY();
        return Math.sqrt(dx * dx + dy * dy);
    }
    
    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof Point)) return false;
        Point p = (Point) obj;
        return p.x == x && p.y == y;
    }
    
    @Override
    public int hashCode() {
        return x|y;
    }
    
    @Override // to let the compilator know I wanted override somthing if there is a typo
    public int compareTo(Point obj) {
        int diff = this.x - obj.x;
        if (diff != 0) return diff;
        return this.y - obj.y;
    }
}

================== with the comppareTo overriden there comparator comes to my mind

public class XOnlyComparator implements Comparator<Point>
{
    public int compare(Point obj1, Point obj2) {
        return obj1.getX() - obj2.getX();
    }
}

================= I played a little with input/output in this one here

public class CountriesIOImpl extends CountriesImpl implements CountriesIO {
    
    private Set<Country> countries = new HashSet<Country>();
 
    public boolean load(InputStream input) throws CountriesException {
        BufferedReader loader = new BufferedReader(new InputStreamReader(input));
        
        try {
            String line = loader.readLine();
            while (line != null) {
                String[] ss = line.split(" ", 2); 
       
                if (ss.length != 2) throw new IOException("Wrong data format");
                try {
                    int population = Integer.parseInt(ss[0]);
                    String name = new String(ss[1]);
                    
                    //System.out.println(countries);
                    
                    countries.add(new Country(name, population));
                } catch(NumberFormatException ex) {
                    throw new IOException("wrong format of data", ex);
                }
                line = loader.readLine();
            }
        } catch (IOException ex) {
            throw new CountriesException("read error", ex);
        }
        return true;
    }
  
    public void save(OutputStream output) throws CountriesException {
         BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(output));
         
         try {
            for (Iterator it = countries.iterator(); it.hasNext(); ) {
                   Country c = (Country) it.next();
                   
                   writer.write(c.getPopulation() + " " + c.getName());
                   writer.newLine();
            }
         
            writer.flush();
         } catch (IOException ex) {
            throw new CountriesException("write error", ex);
         }
    }
    
}

can help with the input/output part a lot thou

  public static void fileWriter() throws IOException {
          FileWriter fw = new FileWriter("out.txt");

    fw.write("adasdda");
    fw.write(System.getProperty("line.separator"));    
    fw.close();
}

public static void bufferedWriter() throws IOException {
    Writer fw = new FileWriter("out.txt");
    BufferedWriter bw = new BufferedWriter(fw);

    bw.write("Ahoj.");
    bw.newLine();

    bw.close();

    //bw = new BufferedWriter(new FileWriter(file, true));
    // pokracuji v zxapise na konec souboru
}

public static void bufferedWriter(Writer writer) throws IOException {
    BufferedWriter bw = new BufferedWriter(writer);

    bw.write("Ahoj.");
    bw.newLine();

    //bw.close();
    bw.flush();
}

public static void bufferedWriterDemo() throws IOException {
    Writer fw = new FileWriter("out.txt");
    bufferedWriter(fw);
    fw.close();
}

public static void fileReader() throws IOException {
    FileReader fr = new FileReader("out.txt");

    int c = fr.read();
    while (c != -1) {
        System.out.println((char)c);
        c = fr.read();
    }

    fr.close();
}

public static void bufferedReader() throws IOException {
    BufferedReader br = new BufferedReader(new FileReader("out.txt"));

    String line = br.readLine();
    while(line != null) {
        System.out.println(line);
        line = br.readLine();
    }

    br.close();
}


public static void outputStreamWriter(OutputStream out) throws IOException {
    OutputStreamWriter writer = new OutputStreamWriter(out, "utf-8");

    writer.write("ěščřžýáíé");

    writer.flush();
}

public static void outputStreamWriterDemo() throws IOException {
    OutputStream os = new FileOutputStream("out.txt");
    outputStreamWriter(os);
    os.close();
}

some other input/output usage

public void write(File file) throws IOException { 
        if (file == null) return;

    /*
    BufferedWriter writer = new BufferedWriter(new FileWriter(file));
    //BufferedWriter writer = new BufferedWriter(new OutputStreamWtriter(new FileOutputStream(file), "utf-8"));

    for (Person p: persons) {
        writer.write(p.toString());
        writer.newLine();
    }

    write.close();
    */

   FileOutputStream fos = new FileOutputStream(file);
   write(fos);
   //write(System.out);
   //write(System.err);
   fos.close();
}

public void write(OutputStream os) throws IOException { 
    if (os == null) return;

    BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(os, "utf-8"));

    for (Person p: persons) {
        writer.write(p.toString());
        writer.newLine();
    }

    //write.close();
    writer.flush();
}


public void writePrintWriter(String file) throws IOException { 
    if (file == null) return;

    //BufferedWriter writer = new BufferedWriter(new FileWriter(file));
    //BufferedWriter writer = new BufferedWriter(new OutputStreamWtriter(new FileOutputStream(file), "utf-8"));
    PrintWriter writer = new PrintWriter(file);
    //PrintWriter writer = new PrintWriter(new FileWriter(file));
    //PrintWriter writer = new PrintWriter(new FileOutputStream(file));

    for (Person p: persons) {
        writer.println(p.toString());
    }

    writer.close();

    if (writer.checkError()) {
        throw new IOException();
    }
}


public void writeClose1(String file) throws IOException { 
    if (file == null) return;

    FileOutputStream fos = null;
    try { 
        fos = new FileOutputStream(file); // throws FileNotFoundException
        write(fos); //. throws IOException
    } finally {
        if (fos != null) fos.close();
    }
}

public void writeClose2(String file) { 
    if (file == null) return;

    try {
        FileOutputStream fos = null;
        try { 
            fos = new FileOutputStream(file); // throws FileNotFoundException
            write(fos); //. throws IOException
        } finally {
            if (fos != null) fos.close();
        }
    } catch(IOException ex) {
        //System.err(ex.getMessage());
    }
}

public void writeClose3(String file) { 
    if (file == null) return;

    FileOutputStream fos = null;
    try { 
        fos = new FileOutputStream(file); // throws FileNotFoundException
        write(fos); //. throws IOException
    } catch(IOException ex) {
        //System.err(ex.getMessage());
    } finally {
        try {
            if (fos != null) fos.close();
        } catch(IOException ex) {
            //System.err(ex.getMessage());
        }                
    }
}

public void read(String file) throws IOException {
    if (file == null) return;

    BufferedReader reader = new BufferedReader(new FileReader(file));

    Set<Person> auxSet = new HashSet<Person>();

    String line = reader.readLine();
    while (line != null) {
        String[] ss = line.split(":");
        if (ss.length != 3) throw new IOException("..");
        String[] adr = ss[2].split(",");
        if (adr.length != 2) throw new IOException("..");

        try {
            auxSet.add(new Person(ss[1], Integer.parseInt(ss[0]), new Address(adr[0], adr[1])));
        } catch(NumberFormatException ex) {
            throw new IOException(ex);
        }

        line = reader.readLine();
    }

    reader.close();

    persons.addAll(auxSet);
}

public void systemInput() throws IOException {
    InputStreamReader fr = new InputStreamReader(System.in);
    System.out.println("Zadejte vstup: ");
    int c = fr.read();
    while (c != -1) {
        System.out.println((char)c);
        c = fr.read();
    }
    System.out.println("Hotovo, jede se dal");
    fr.close();
}

with the custom comparator you do this kind of stuff

public SortedSet<Point> getSortedPoints(Comparator<Point> comp) {
    SortedSet<Point> ret = new TreeSet<Point>(comp);        
    ret.addAll(vertices.values());
    return ret;
}