Sie sind auf Seite 1von 31

TEST JAVA

PASAGER
package eu.ase;

import java.io.Serializable;

public abstract class Pasager implements Serializable {

    private static final long serialVersionUID = 1L;
    private String nume;
    private float numarLoc;
    private float varsta;
    private final int idRezervare;
    
    public Pasager(String _nume, float _numarLoc, float _varsta, int _idRezervare)
    {
        this.nume=_nume;
        this.numarLoc=_numarLoc;
        this.varsta=_varsta;
        this.idRezervare=_idRezervare;
    }

    public String getNume() {
        return nume;
    }

    public float getNumarLoc() {
        return numarLoc;
    }

    public float getVarsta() {
        return varsta;
    }

    public int getId() {
        return idRezervare;
    }
    
    public abstract String getidRezervare();
    
}
PASAGERVIP
package eu.ase;

import java.io.Serializable;

public class PasagerVIP extends Pasager implements Cloneable, Serializable, Comparable<PasagerVIP> {

    private static final long serialVersionUID = 1L;
    private String nrCardVIP;
    
    public PasagerVIP(String _nume, float _numarLoc, float _varsta, int _idRezervare, String _nrCard) throws Ex
ception {
        super(_nume, _numarLoc, _varsta, _idRezervare);
        if(this.getNumarLoc()<0)
            throw new Exception("Should not be negative.");
        this.nrCardVIP=_nrCard;
    }

    @Override
    public String getidRezervare() {
        return this.getId() + " " + this.nrCardVIP;
    }

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof PasagerVIP))
            return false;
        else
        {
            PasagerVIP p = (PasagerVIP)obj;
            return this.getNume().equals(p.getNume()) && (int)this.getNumarLoc() == (int)p.getNumarLoc()
                    && (int)this.getVarsta()==(int)p.getVarsta() && this.getId() == p.getId() && this.nrCardVIP.equals
(p.nrCardVIP);    
        }
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        PasagerVIP clone = (PasagerVIP)super.clone();
        clone.nrCardVIP=this.nrCardVIP;
        return clone;
    }

    @Override
    public String toString() {
        return this.getId() + " ";
    }

    @Override
    public int compareTo(PasagerVIP o) {
        return Integer.compare(this.getId(), o.getId());
    }
    

}
PASAGEREC
package eu.ase;
import java.io.Serializable;

public class PasagerEc extends Pasager implements Cloneable, Serializable, Comparable<PasagerEc> {

    private static final long serialVersionUID = 1L;
    private String nrCardEc;
    
    public PasagerEc(String _nume, float _numarLoc, float _varsta, int _idRezervare, String _nrCard) throws Exc
eption {
        super(_nume, _numarLoc, _varsta, _idRezervare);
        if (this.getNumarLoc() < 0)
            throw new Exception("Should not be negative.");
        this.nrCardEc=_nrCard;
    }

    @Override
    public String getidRezervare() {
        return this.getId() + " " +this.nrCardEc;
    }

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof PasagerEc))
            return false;
        else
        {
            PasagerEc p = (PasagerEc)obj;
            return this.getNume().equals(p.getNume()) && (int)this.getNumarLoc() == (int)p.getNumarLoc()
                    && (int)this.getVarsta()==(int)p.getVarsta() && this.getId() == p.getId() && this.nrCardEc.equals(
p.nrCardEc);    }
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        PasagerEc clone = (PasagerEc)super.clone();
        clone.nrCardEc=this.nrCardEc;
        return clone;
    }
    
    @Override
    public String toString() {
        return this.getId() + " ";
    }

    @Override
    public int compareTo(PasagerEc o) {
        return Integer.compare(this.getId(), o.getId());
    }
    
}

MATRICE
package eu.ase;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.StringTokenizer;
import java.util.Vector;

public class Matrice implements Cloneable, Comparable<Matrice>, Serializable {

    private static final long serialVersionUID = 1L;
    private int nrLinii;
    private int nrColoane;
    private Object[][] container;
    
    public Matrice()
    {
        
    }
    
    
public Matrice(int _nrLinii, int _nrColoane, Object[][] _container)
    {
        this.nrLinii=_nrLinii;
        this.nrColoane=_nrColoane;
        this.container = new Object[this.nrLinii][this.nrColoane];
        for (int i=0; i<this.nrLinii; i++)
        {
            for (int j=0; j<this.nrColoane; j++)
                this.container[i][j]=_container[i][j];
        }
    }

    public void setNrLinii(int nrLinii) {
        this.nrLinii = nrLinii;
    }

    public void setNrColoane(int nrColoane) {
        this.nrColoane = nrColoane;
    }

    public void setContainer(Object[][] container) {
        this.container = container;
    }

    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof Matrice))
            return false;
        else
        {
            Matrice m = (Matrice)obj;
            if (this.nrLinii!=m.nrLinii)
                return false;
            if (this.nrColoane!=m.nrColoane)
                return false;
            for (int i=0; i<this.nrLinii; i++)
            {
                for (int j=0; j<this.nrColoane; j++)
                {
                    if (!(this.container[i][j].equals(m.container[i][j])))
                        return false;
                }
            }
        }
        return true;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Matrice clone = (Matrice)super.clone();
        clone.nrLinii=this.nrLinii;
        clone.nrColoane=this.nrColoane;
        if (this.container!=null)
        {
            clone.container=new Object[this.nrLinii][this.nrColoane];
            for (int i=0; i<this.nrLinii; i++)
            {
                for (int j=0; j<this.nrColoane; j++)
                {
                    clone.container[i][j]=this.container[i][j];
                }
            }
        }
        return clone;
    }
    
    public Object minim()
    {
        Object minim = this.container[0][0];
        for (int i=0; i<this.nrLinii; i++)
        {
            for (int j=0; j<this.nrColoane; j++)
            {
                if (this.container[i][j].hashCode()<minim.hashCode())
                    minim=this.container[i][i];
            }
        }
        return minim;
    }
    @Override
    public int compareTo(Matrice o) {
        return Integer.compare(this.nrLinii, o.nrLinii);
    }
    
    public void CitireDinFisier(String fileName)
    {
        BufferedReader in = null;
        try {
            in = new BufferedReader(new FileReader(new File(fileName)));
            String line = null;
            while ((line=in.readLine())!=null)
            {
                StringTokenizer st = new StringTokenizer(line, "#");
                String nume = st.nextToken();
                String numarLoc = st.nextToken();
                String varsta = st.nextToken();
                String idRezervare = st.nextToken();
                String nrCard=st.nextToken();
                if (fileName.equals("PasagerEc.txt"))
                {
                    PasagerEc pe = new PasagerEc(nume, Float.parseFloat(numarLoc), Float.parseFl
oat(varsta), Integer.parseInt(idRezervare), nrCard);
                    int k=0;
                    for (int i=0; i<this.nrLinii; i++)
                    {
                        for (int j=0; j<this.nrColoane; j++)
                        {
                            k++;
                            if (pe.getNumarLoc() == k)
                            {
                                this.container[i][j]=pe;
                            }
                        }
                    }
                }
                else if (fileName.equals("PasagerVIP.txt"))
                {
                    PasagerVIP pv=new PasagerVIP(nume, Float.parseFloat(numarLoc), Float.parse
Float(varsta), Integer.parseInt(idRezervare), nrCard);
                    int k=0;
                    for (int i=0; i<this.nrLinii; i++)
                    {
                        for (int j=0; j<this.nrColoane; j++)
                        {
                            k++;
                            if (pv.getNumarLoc() == k)
                            {
                                this.container[i][j]=pv;
                            }
                        }
                    }
                }
                
            }
            in.close();
        } 
        catch (Exception e)
        { e.printStackTrace(); }
        
    }
    
    public void displayMatrice()
    {
        for (int i=0; i<this.nrLinii; i++)
        {
            for (int j=0; j<this.nrColoane; j++)
            {
                System.out.print(container[i][j] + " ");
            }
            System.out.println();
        }
    }
    
    public void sortare()
    {
        List<Pasager> lista = new ArrayList<Pasager>();
        for (int i=0; i<this.nrLinii; i++)
        {
            for (int j=0; j<this.nrColoane; j++)
            {
                    lista.add((Pasager)container[i][j]);
            }
        }
        
        Collections.sort(lista, (a,b)->Integer.compare(a.getId(), b.getId()));
        int k=0;
        for (int i=0; i<this.nrLinii; i++)
        {
            for (int j=0; j<this.nrColoane; j++)
            {    
                    {
                        this.container[i][j]=lista.get(k);
                        k++;
                    }
            }
        }
        
    }
    
    public void transpune()
    {
        Vector<Pasager> vector = new Vector<Pasager>();
        for (int i=0; i<this.nrLinii; i++)
        {
            for (int j=0; j<this.nrColoane; j++)
            {
                    vector.add((Pasager)container[i][j]);
            }
        }
        
        for (Pasager p : vector)
            System.out.println(p);
    }
    
    
}

MAIN
package eu.ase;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class Main {

    public static void main(String[] args) throws Exception {
        PasagerEc pe = new PasagerEc("Anda", 1, 23, 12, "Card1");
        PasagerVIP pv = new PasagerVIP("Alexa", 2, 20, 17, "Card2");
        
        System.out.println(pe.getidRezervare());
        System.out.println(pv.getidRezervare());
        
        PasagerEc peclone = (PasagerEc)pe.clone();
        PasagerVIP pvclone = (PasagerVIP)pv.clone();
        
        if(peclone.equals(pe))
            System.out.println("They are equal");
        else System.out.println("They are not equal");
        
        if (pvclone.equals(pv))
            System.out.println("They are equal");
        else System.out.println("They are not equal.");
        
        Object[][] objects= new Object[][]{{pe,peclone},{pv,pvclone}};
        Matrice m = new Matrice(2,2, objects);
        System.out.println(m.minim());
        
        Object[][] objects2= new Object[][]{{1,2},{3,4}};
        Matrice m2 = new Matrice(2,2, objects2);
        System.out.println(m2.minim());
        
        Matrice m_clone = (Matrice)m.clone();
        if (m.equals(m_clone))
            System.out.println("They are equal.");
        else System.out.println("They are not equal.");
        
        Matrice x = new Matrice();
        x.setNrLinii(2);
        x.setNrColoane(4);
        Object[][] values = new Object[2][4];
        x.setContainer(values);
        x.CitireDinFisier("PasagerEc.txt");
        x.CitireDinFisier("PasagerVIP.txt");
        x.displayMatrice();
        
        System.out.println("-------Serializare-------");
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("b
inar.txt")));
        oos.writeObject(x);
        oos.close();
        
        System.out.println("-------Deserializare-------");
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("binar.t
xt")));
        Matrice o = (Matrice)ois.readObject();
        ois.close();
        o.displayMatrice();
        
        System.out.println("-----Sortare-------");
        o.sortare();
        o.displayMatrice();
        
        System.out.println("-----Transpune-----");
        o.transpune();
    }

*PROBLEMA
Să se scrie o aplicație pentru evidența materiilor prime și materialelor din patrimoniul unei
societăți. Pentru realizarea aplicației for fi folosite următoarele clase și interfețe:

 Clasa MPMat care va avea câmpurile: cod (int), denumire (String), valoare
(double) și tip (TipM). Clasa

va conține un constructor default și un constructor de inițializare pentru cele patru


câmpuri, metode de acces pentru aceste câmpuri, implementare furnizarea conținutului
de tip String (toString), va avea implementări pentru egalitate între obiecte după
câmpul cod și pentru comparații între obiecte după câmpul cod.

 Enumerarea TipM care va avea constantele MATERIAL (3011),


MATERIE_PRIMA (300), COMBUSTIBIL (3012). Enumerarea va avea un câmp de
tip int pentru simbolul contabil asociat fiecărui tip.

 Interfața IO prin care vor fi implementate operațiuni de citire din fișier text,
citire/scriere din/în fișiere binare. Metodele interfeței vor fi: citire (pentru citire din
fișier text), salvare (pentru scriere în fișier binar) și restaurare (citire din fișier binar).
Metodele vor primi ca parametru numele fișierului din/în care se va face
citirea/scrierea și vor arunca excepții.

 Interfața Operatiuni prin care vor fi implementate operațiuni de colectare


informație din lista de materiale. Metode cerute:

o sort1() - sortarea într-o listă nouă a materialelor după cod


o sort2() - sortarea într-o listă nouă a materialelor după valoare
o filtrare(TipM tip) - filtrarea într-o lista nouă a materialelor dintr-un tip specificat ca
parametru o valoareMateriale() - colectarea într-o structură Map a valorilor totale pe tip de
materiale

Clasa MainMP va fi clasa principală a aplicației, care va conține metoda statică main și va
implementa interfețele IO și Operatiuni. Clasa va conține un câmp lista de tip List<MPMat>
în care vor fi memorate materialele.

Cerințele aplicației:

1. Definiți clasele/interfețele menționate în conformitate cu specificațiile avute (mai


puțin implementarea

interfețelor IO și Operațiuni pentru MainMP) (3 puncte)

2. Implementați interfața IO (3 puncte - câte un punct pentru fiecare metodă)


3. Implementați interfața Operațiuni (sort1 - 0.5 puncte, sort2 - 0.5 puncte, filtrare - 1 punct,

valoareMateriale - 1 punct)

MPMAT
package seminar;

import java.io.Serializable;
import java.util.Objects;

public class MPMat implements Comparable<MPMat>, Serializable {
    private int cod;
    private String denumire;
    private double valoare;
    private TipM tip;

    public MPMat() {
    }

   
 public MPMat(int cod, String denumire, double valoare, TipM tip) {
        this.cod = cod;
        this.denumire = denumire;
        this.valoare = valoare;
        this.tip = tip;
    }

    public int getCod() {
        return cod;
    }

    public void setCod(int cod) {
        this.cod = cod;
    }

    public String getDenumire() {
        return denumire;
    }

    public void setDenumire(String denumire) {
        this.denumire = denumire;
    }

    public double getValoare() {
        return valoare;
    }
    public void setValoare(double valoare) {
        this.valoare = valoare;
    }

    public TipM getTip() {
        return tip;
    }

    public void setTip(TipM tip) {
        this.tip = tip;
    }

    @Override
    public String toString() {
        return cod+","+denumire+","+valoare+","+tip;
    }

   

 @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass())
 return false;
        MPMat mpMat = (MPMat) o;
        return cod == mpMat.cod;
    }

    @Override
    public int hashCode() {
        return Objects.hash(cod);
    }

    @Override
    public int compareTo(MPMat o) {
        return cod<o.cod?-1:1;
    }
}

TIPM
package seminar;

public enum TipM {
    MATERIAL(3011),MATERIE_PRIMA(300),COMBUSTIBIL(3012);
    private int cont;
    TipM(int cont) {
        this.cont = cont;
    }

    public int getCont() {
        return cont;
    }
}

OPERATIUNI
package seminar;

import java.util.List;
import java.util.Map;

public interface Operatiuni {
    List<MPMat> sort1();
    List<MPMat> sort2();
    List<MPMat> filtrare(TipM tip);
    Map<TipM,Double> valoareMateriale();
}

IO
package seminar;

public interface IO {
    void citire(String fisier) throws Exception;
    void salvare(String fisier) throws Exception;
    void restaurare(String fisier) throws Exception;
}

MAINMP
package seminar;

import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class MainMP implements IO,Operatiuni {
    private List<MPMat> lista = new ArrayList<>();

    public static void main(String[] args) {
        MainMP app = new MainMP();
        try{
            app.citire("matp.csv");
//            app.afisareLista();
            app.salvare("matp.dat");
            app.restaurare("matp.dat");
            System.out.println("Lista materiale:");
            app.afisareLista();
            System.out.println("\nLista sortata dupa cod:");
            app.sort1().forEach(System.out::println);
            System.out.println("\nLista sortata dupa valoare:");
            app.sort2().forEach(System.out::println);
            System.out.println("\nLista combustibililor:");
            app.filtrare(TipM.valueOf("COMBUSTIBIL")).forEach(System.out::println);
            Map<TipM,Double> valori = app.valoareMateriale();
            System.out.println("\nValoare materiale pe tipuri:");
            valori.keySet().forEach(tip->{
                System.out.println(tip+":"+valori.get(tip));
            });
           
        }
        catch (Exception ex){
            System.err.println(ex);
        }
    }

   
 @Override
    public void citire(String fisier) throws Exception {
        try(BufferedReader in = new BufferedReader(new FileReader(fisier))){
            in.lines().forEach(linie->{
                String[] t = linie.split(",");
                MPMat mat = new MPMat();
                mat.setCod(Integer.parseInt(t[0].trim()));
                mat.setDenumire(t[1].trim());
                mat.setValoare(Double.parseDouble(t[2].trim()));
                mat.setTip(TipM.valueOf(t[3].trim().toUpperCase()));
                lista.add(mat);
            });
        }
    }

    private void afisareLista(){
        lista.forEach(System.out::println);
    }

    @Override
    public void salvare(String fisier) throws Exception {
        try(ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(fisier))){
            for (MPMat mat : lista) {
                out.writeObject(mat);
            }
        }
    }

    @Override
    public void restaurare(String fisier) throws Exception {
        try(FileInputStream in1 = new FileInputStream(fisier);
        ObjectInputStream in = new ObjectInputStream(in1)){
            lista.clear();
            while (in1.available()!=0){
                lista.add((MPMat)in.readObject());
            }
        }
    }

    @Override
    public List<MPMat> sort1() {
        return lista.stream().sorted().collect(Collectors.toList());
    }

   
 @Override
    public List<MPMat> sort2() {
        return lista.stream().sorted((mat1,mat2)->mat1.getValoare()<mat2.getValoare()?-1:1)
                .collect(Collectors.toList());
    }

    @Override
    public List<MPMat> filtrare(TipM tip) {
        return lista.stream().filter(mat->mat.getTip().equals(tip)).collect(Collectors.toList());
    }

    @Override
    public Map<TipM, Double> valoareMateriale() {
        Map<TipM, Double> listaValoare = lista.stream().collect(Collectors.groupingBy((MPM
at mat)->mat.getTip(),
                Collectors.summingDouble((MPMat mat)->mat.getValoare())));
        return listaValoare;
    }
}

**PROBLEMA
Să se scrie o aplicație pentru evidența mijloacelor fixe din patrimoniul unei societăți. Pentru
realizarea aplicației vor fi folosite următoarele clase și interfețe:

 Clasa MijlocFix care va avea câmpurile: cod (int), denumire (String), valoare
(double) și categoria

(Categorii). Clasa va conține un constructor default și un constructor de inițializare


pentru cele patru câmpuri, metode de acces pentru aceste câmpuri, metodă pentru
furnizarea conținutului de tip String (toString), va avea implementări pentru egalitate
între obiecte după câmpul cod și pentru comparații între obiecte după câmpul cod.

 Enumerarea Categorii care va avea constantele TERENURI (211, 100),


CONSTRUCTII (212, 100), ECHIPAMENTE (2131, 10), MIJLOACE_TRANSPORT
(2133, 6) și MOBILIER (214, 10). Enumerarea va avea două câmpuri, un câmp de tip
int pentru simbolul contabil asociat fiecărei categorii și un câmp de tip int pentru
durata normată de funcționare în ani.
 Interfața Amortizare care va fi implementată de clasa MijlocFix. Interfața are o
singură metodă, calcul, care calculează și întoarce valoarea amortizării pe o lună.
 Interfața IO prin care vor fi implementate operațiuni de citire din fișier text,
citire/scriere din/în fișiere binare. Metodele interfeței vor fi: citire (pentru citire din
fișier text), salvare (pentru scriere în fișier binar) și restaurare (citire din fișier binar).
Metodele vor primi ca parametru numele fișierului din/în care se va face
citirea/scrierea și vor arunca excepții.
 Interfața Operatiuni prin care vor fi implementate operațiuni de colectare
informație din lista de mijloace fixe. Metode cerute:

o sort1() - sortarea într-o listă nouă a mijloacelor fixe după cod


o sort2() - sortarea într-o listă nouă a mijloacelor fixe după valoare
o filtrare(Categorie categorie) - filtrarea într-o lista nouă a mijloacelor fixe dintr-o categorie

specificată ca parametru
o valoareMijloaceFixe() - colectarea într-o structură Map a valorilor totale pe categorii de

mijloace fixe
Clasa MainMF va fi clasa care va conține metoda statică main și va implementa interfețele
IO și

Operatiuni. Clasa va conține un câmp lista de tip List<MijloaceFixe> în care vor fi memorate

mijloacele fixe. Cerințele aplicației:

1. Definiți clasele/interfețele menționate în conformitate cu specificațiile avute (mai


puțin implementarea

interfețelor IO și Operațiuni pentru MainMF) (3 puncte)

2. Implementați interfața IO (3 puncte - câte un punct pentru fiecare metodă)

3. Implementați interfața Operațiuni (sort1 - 0.5 puncte, sort2 - 0.5 puncte, filtrare - 1 punct,

valoareMijloaceFixe - 1 punct)
MIJLOCFIX
import java.io.Serializable;
import java.util.Objects;

public class MijlocFix implements Comparable<MijlocFix>, Serializable, Amortizare{
private int cod;
private String denumire;
private Double valoare;
private Categorii categoria;
public MijlocFix() {
    super();
}
public MijlocFix(int cod, String denumire, Double valoare, Categorii categoria) {
    super();
    this.cod = cod;
    this.denumire = denumire;
    this.valoare = valoare;
    this.categoria = categoria;
}
public int getCod() {
    return cod;
}
public void setCod(int cod) {
    this.cod = cod;
}
public String getDenumire() {
    return denumire;
}
public void setDenumire(String denumire) {
    this.denumire = denumire;
}
public Double getValoare() {
    return valoare;
}
public void setValoare(Double valoare) {
    this.valoare = valoare;
}
public Categorii getCategoria() {
    return categoria;
}
public void setCategoria(Categorii categoria) {
    this.categoria = categoria;
}

@Override
public String toString() {
    return  cod + ", " + denumire + "," + valoare + "," + categoria ;
}
@Override
public int hashCode() {
    
    return Objects.hash(cod);
}
@Override
public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null||getClass() != obj.getClass())
        return false;
    
    MijlocFix other = (MijlocFix) obj;
    return cod==other.cod;
}
@Override
public int compareTo(MijlocFix o) {
    return cod<o.cod?-1:1;
}
@Override
public double calcul() {
    return valoare/12;
}

CATEGORII
public enum Categorii {
TERENURI(211, 100), CONSTRUCTII(212,100), ECHIPAMENTE(2131,10), MIJLOACE_
TRANSPORT(2133,6), MOBILIER(214,10);
    private int cont;
    private int durata;
    private Categorii(int cont, int durata) {
        this.cont = cont;
        this.durata = durata;
    }
    public int getCont() {
        return cont;
    }
    public void setCont(int cont) {
        this.cont = cont;
    }
    public int getDurata() {
        return durata;
    }
    public void setDurata(int durata) {
        this.durata = durata;
    }
    
    
}

AMORTIZARE
public interface Amortizare {
double calcul();
}

OPERATIUNI
import java.util.List;
import java.util.Map;

public interface Operatiuni {
List<MijlocFix>sortCod();
List<MijlocFix>sortVal();
List<MijlocFix>sortDem();
List<MijlocFix>filtrare(Categorii cat);
Map<Categorii, Double>valoareMateriale();
}

IO
public interface IO {
void citire(String nume) throws Exception;
void salvare(String nume)throws Exception;
void restaurare(String nume)throws Exception;
}
MAIN MIJLOC
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.function.ObjDoubleConsumer;
import java.util.stream.Collectors;

public class MainMIjloc implements IO, Operatiuni{
private List<MijlocFix> lista = new ArrayList<MijlocFix>();
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        MainMIjloc app = new MainMIjloc();
        try {
            app.citire("date.csv");
            System.out.println("afisare lista:");
            app.afisareLista();
            app.salvare("binar.dat");
            app.restaurare("binar.dat");
            System.out.println("\nLista sortata dupa cod:");
            app.sortCod().forEach(System.out::println);
            System.out.println("\nLista sortata dupa denumire:");
            app.sortDem().forEach(System.out::println);
            System.out.println("\nLista sortata dupa valoare:");
            app.sortVal().forEach(System.out::println);
            System.out.println("\nLista materiale constructii:");
            app.filtrare(Categorii.valueOf("CONSTRUCTII")).forEach(System.out::println);
            Map<Categorii, Double>valori = app.valoareMateriale();
            System.out.println("\nValoare Mijloace fixe: ");
            valori.keySet().forEach(categorie->{
                System.out.println(categorie+":"+valori.get(categorie));
            });
        } catch (Exception ex) {
            System.err.println(ex.toString());
        }

    }

    @Override
    public void citire(String nume) throws Exception {
    try(BufferedReader in = new BufferedReader(new FileReader(nume))){
        in.lines().forEach(linie->{
            String[]t = linie.split(",");
            MijlocFix fix = new MijlocFix();
            fix.setCod(Integer.parseInt(t[0].trim()));
            fix.setDenumire(t[1].trim());
            fix.setValoare(Double.parseDouble(t[2].trim()));
            fix.setCategoria(Categorii.valueOf(t[3].trim().toUpperCase()));
            lista.add(fix);
            
            
            
            System.out.println("Afisare Amortizari:\n "+fix.calcul());
            
            
        });
    
    }
        
    }

    public void afisareLista() {
        lista.forEach(System.out::println);
    }
    @Override
    public void salvare(String nume) throws Exception {
    try(ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(nume))){
        for(MijlocFix mf:lista) {
            out.writeObject(mf);
        }
    }
        
    }

  

  @Override
    public void restaurare(String nume) throws Exception {
        try(FileInputStream in1 = new FileInputStream(nume);
                ObjectInputStream in = new ObjectInputStream(in1)){
            lista.clear();
            while(in1.available()!=0) {
                lista.add((MijlocFix)in.readObject());
            }
        }
        
    }

    @Override
    public List<MijlocFix> sortCod() {
        return lista.stream().sorted().collect(Collectors.toList());
    }

    @Override
    public List<MijlocFix> sortVal() {
        return lista.stream().sorted((mij1,mij2)->mij1.getValoare()<mij2.getValoare()?-
1:1).collect(Collectors.toList());
    }

    @Override
    public List<MijlocFix> filtrare(Categorii cat) {
        return lista.stream().filter(categorie-
>categorie.getCategoria().equals(cat)).collect(Collectors.toList());
    }

    @Override
    public Map<Categorii, Double> valoareMateriale() {
    Map<Categorii, Double>listaVal = lista.stream().collect(Collectors.groupingBy((MijlocFix 
mij)->mij.getCategoria(),
            Collectors.summingDouble((MijlocFix mij)->mij.getValoare())));
    return listaVal;
    }

    @Override
    public List<MijlocFix> sortDem() {
        return lista.stream().sorted((mij1, mij2)-
>mij1.getDenumire().compareTo(mij2.getDenumire())).collect(Collectors.toList());
    }

}
SUBIECTE ANII TRECUTI
Subiectul 1 Nume, grupa, stația:
______________________________________________________________________

Să se scrie o aplicație pentru gestiunea proiectelor de cercetare monitorizate de departamentul


de cercetare. Proiectele sunt memorate în două fișiere text, P1.txt și P2.txt, pentru fiecare
proiect fiind alocate două rânduri. Pe primul rând sunt memorate: codul proiectului (long),
titlul (String), bugetul alocat (double), durata proiectului în luni (int). Pe a doilea rând sunt
memorate persoanele din echipa de cercetare, astfel: nume 1 (String), nume 2 (String) , ...,
nume N (String).
Aplicația va implementa următoarele funcționalități:
A. Citirea proiectelor din fișierele text și memorarea lor într-o listă. Se va utiliza o clasă
Proiect cu structura corespunzătoare unui proiect.
B. Calculul bugetului lunar pentru fiecare persoana din proiect, considerând că membrii
echipei vor fi egal retribuiți. Calculul se va face prin metoda calcul a interfeței Operatiuni
implementată de clasa Proiect.
C. Proiectele vor fi salvate în două fișiere B1.txt și B2.txt, în ordinea descrescătoare a
bugetelor lunare pe persoană, pentru fiecare proiect fiind afișat codul și bugetul lunar pe
persoană.
D. Sarcinile vor fi executate în paralel, pe două fire de execuție, câte unul pentru fiecare fișier
de intrare.
Exemplu
P1.txt: P2.txt: B1.txt: B2.txt:
120,Titlu 1,39000,25 150,Titlu 3,150000,36 100,1666,66 200,2083.33
Popescu I,Ionescu D Ionescu P,Dumitrescu I,Popa 120,780 150,1388.88
100,Titlu 2,100000,20 M
Ion I,Pop D,Georgescu 200,Titlu 4,100000,24
G Popescu S,Popescu F

Subiectul 2 Nume, grupa, stația:


_______________________________________________________________

În fișierul text, Depozit.txt sunt memorate informații privind stocurile unei societăți
comerciale. Pe fiecare linie se găsesc informații privind un stoc, și anume: cod stoc (int),
denumire stoc (String), stoc inițial (double), intrări (double) și ieșiri (double). Să se scrie o
aplicație Java care execută următoarele operațiuni:
A. Citirea informațiilor din fișier și memorarea lor într-o structură de tip
HashMap<Integer,Stoc>, unde Integer este codul stocului iar Stoc este clasa utilizată pentru
stoc;
B. Actualizarea stocurilor pornind de la două fișiere de tranzacții, Input1.txt și Input2.txt, pe
fiecare linie în fișiere fiind specificat un cod de stoc și cantitatea intrată. Actualizarea constă
în incrementarea intrărilor existente cu cantitatea intrată prin fișierul de tranzacții.
C. Salvarea după actualizare a noului disponibil pentru fiecare stoc, într-un fișier text
Disponibil.txt, pe fiecare linie fiind memorat codul stocului și disponibilul.
Disponibilul este stocul inițial plus intrări minus ieșiri.
Metoda de actualizare stoc va fi definită într-o interfață Gestiune, implementată de clasa Stoc.
Actualizarea stocurilor se va face în regim paralel, pe două fire de execuție, câte unul pentru
fiecare fișier de tranzacții.
Exemplu
Depozit.txt: Input1.txt: Input2.txt: Disponibil.txt:
1,ciment,100,100,50 1,50 1,100 1,300
2,adeziv 3,40 2,100 2,360
ct127,200,100,40 3,60
3,adeziv ct126,50,0,30

Subiectul 3 Nume, grupa, stația:


_____________________________________________________________________

Să se scrie o aplicație care să calculeze suma elementelor de pe diagonala principală ale unor
matrice rare și care să salveze rezultatele în fișiere text. Matricele rare sunt citite din două
fișiere text, M1.txt și M2.txt, cu matricele memorate pe câte un rând, astfel:
v1,l1,c1, v2,l2,c2, ..., vm,lm,cm
unde m este numărul de elemente din matrice, iar li și ci sunt pozițiile elementelor în matrice,
linie și coloană.
Se va uiliza o clasă Matrice, care va conține o colecție de date (tip Collection) pentru
memorarea elementelor (la alegere), și care va implementa o interfață Operațiuni, cu o
singură metodă abstractă, suma, pentru calculul sumei elementelor de pe diagonala principală.
Calculele se vor efectua în paralel, câte un fir pentru fiecare fișier de intrare. După efectuarea
calculelor, matricele vor fi salvate în ordinea descrescătoare a sumelor, în fișierele text
Out1.txt și Out2.txt, pe fiecare linie câte o matrice, astfel:
(v1,l1,c1), (v2,l2,c2), ..., (vm,lm,cm), suma

Exemplu
M1.txt: M2.txt: Out1.txt: Out2.txt:
100,0,0,120,10,20,100, 5,0,0,10,1,1 (100,0,0),(120,10,20), (5,0,0),(10,1,1),15
20,20 12,0,2,10,0,1,25 (100,20,20),200 (12,0,2),(10,0,1),
12,0,2,10,1,1,25,3,5,30 ,7,5 (12,0,2),(10,1,1),(25,3,5), (25,7,5),0
,4,8 (30,4,8),10
Subiectul 4 Nume, grupa, stația:
____________________________________________________________________

Să se scrie o aplicație care să calculeze perimetrul unor poligoane și să salveze rezultatele în


fișiere text. Poligoanele sunt citite din două fișiere text, P1.txt și P2.txt, fiecare poligon fiind
memorat pe câte un rând, astfel:
x1,y1,x2,y2, ..., xm,ym
unde m este numărul de puncte din care este alcătuit poligonul, iar (xi,yi) sunt coordonatele
plane ale punctelor, furnizate în ordine.
Se va folosi o clasă Poligon, care va conține o colecție de date (Collection) pentru memorarea
punctelor (la alegere), și care va implementa o interfață Operațiuni, cu o singură metodă
abstractă, perimetru, pentru calculul perimetrului. Calculele vor fi efectuate în regim paralel,
pe două fire de execuție, câte unul pentru fiecare fișier text de intrare. După efectuarea
calculelor, poligoanele vor fi salvate în ordinea descrescătoare a perimetrelor, în fișierele text
Out1.txt și Out2.txt, pe fiecare linie câte un poligon, astfel:
(x1,y1), (x2,y2), ..., (xm,ym), perimetru
Notă. Distanța dintre două puncte (x1,y1), (x2,y2) se calculează astfel: d =
2 2
√ ( x −x ) +( y − y )
1 2 1 2 .

Exemplu
P1.txt: P2.txt: Out1.txt: Out2.txt:
1,1,4,1,4,4,1,4 1,1,4,1,1,4 (1,1),(4,1),(4,4),(1,4),12 (1,1),(4,1),(1,4),10.24
1,1,3,1,3,2,1,2 1,1,3,1,1,2 (1,1),(3,1),(3,2),(1,2),6 (1,1),(3,1),(1,2),5.23

Subiectul 1

PROIECT
package test;

import java.util.ArrayList;
import java.util.List;

public class Proiect implements Operatiuni,Comparable<Proiect>{
    private int cod;
    private String titlu;
    private double buget;
    private int durata;
    private final List<String> echipa=new ArrayList<>();

    public Proiect() {
    }
    public Proiect(int cod, double buget, int durata) {
        this.cod = cod;
        this.buget = buget;
        this.durata = durata;
    }
    
    public void addMembru(String nume){
        echipa.add(nume);
    }

    public int getCod() {
        return cod;
    }

    public void setCod(int cod) {
        this.cod = cod;
    }

    public double getBuget() {
        return buget;
    }

    public void setBuget(double buget) {
        this.buget = buget;
    }

    public int getDurata() {
        return durata;
    }

    public void setDurata(int durata) {
        this.durata = durata;
    }

    public String getTitlu() {
        return titlu;
    }

    public void setTitlu(String titlu) {
        this.titlu = titlu;
    }

    @Override
    public String toString() {
        return cod + "," + calcul();
    }

    @Override
    public double calcul() {
        return buget/(durata*echipa.size());
    }

    @Override
    public int compareTo(Proiect o) {
        double valoareCurenta = calcul();
        double cealaltaValoare = o.calcul();
        if(valoareCurenta<cealaltaValoare){
            return 1;
        }
        else {
            return -1;
        }
    }
    
    
}

OPERATIUNI
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package test;

/**
 *
 * @author titus
 */
public interface Operatiuni {
    double calcul();
}

PRELUCRARE
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package test;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;

/**
 *
 * @author titus
 */
public class Prelucrare extends Thread {

    private final String fisierInput, fisierOutput;

    public Prelucrare(String fisierInput, String fisierOutput) {
        this.fisierInput = fisierInput;
        this.fisierOutput = fisierOutput;
    }

    @Override
    public void run() {
        //Cerinta A
        List<Proiect> listaProiecte = new ArrayList<>();
        try (BufferedReader in = new BufferedReader(new FileReader(fisierInput))) {
            String linie;
            while ((linie = in.readLine()) != null) {
                Proiect proiect = new Proiect();
                String[] t = linie.split(",");
                proiect.setCod(Integer.parseInt(t[0].trim()));
                proiect.setTitlu(t[1].trim());
                proiect.setBuget(Double.parseDouble(t[2].trim()));
                proiect.setDurata(Integer.parseInt(t[3].trim()));
                linie = in.readLine();
                t = linie.split(",");
                for (String membru : t) {
                    proiect.addMembru(membru);
                }
                listaProiecte.add(proiect);
            }
        } catch (Exception ex) {
            System.err.append(ex.toString());
        }
        // Cerintele B si C
        try (PrintWriter out = new PrintWriter(fisierOutput)) {
            listaProiecte.stream().sorted().forEach(proiect -> {
                out.println(proiect);
            });
        } catch (Exception ex) {
            System.err.append(ex.toString());
        }
    }
}

SUBIECT 1
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package test;

/**
 *
 * @author titus
 */
public class Subiect1 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        try{
            Prelucrare fir1=new Prelucrare("P1.txt", "B1.txt");
            Prelucrare fir2=new Prelucrare("P2.txt", "B2.txt");
            fir1.start();fir2.start();
            fir1.join();fir2.join();
        }
        catch(Exception ex){
            System.err.append(ex.toString());
        }
    }
    
}