Guest User

Untitled

a guest
Oct 19th, 2018
89
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 4.27 KB | None | 0 0
  1. import java.util.*;
  2. import java.io.*;
  3.  
  4. class InOut {
  5.    
  6.     public static int [] readIntegers (String filename) {
  7.     ArrayList<Integer> l = new ArrayList<Integer> ();
  8.     try {
  9.         File f = new File (filename);
  10.         FileReader r = new FileReader (f);
  11.         BufferedReader b = new BufferedReader (r);
  12.         String s = b.readLine ();
  13.         while (s != null) {
  14.         l.add (Integer.parseInt (s));
  15.         s = b.readLine ();
  16.         }
  17.         b.close();
  18.     }
  19.     catch (Exception e) {
  20.         e.printStackTrace ();
  21.     }
  22.     int [] num = new int [l.size ()];
  23.     for (int i = 0; i < l.size (); i++) {
  24.         num [i] = l.get (i);
  25.     }
  26.     return num;
  27.     }
  28.    
  29.     public static double [] readDoubles (String filename) {
  30.     ArrayList<Double> d = new ArrayList<Double> ();
  31.     try {
  32.         File f = new File (filename);
  33.         FileReader r = new FileReader (f);
  34.         BufferedReader b = new BufferedReader (r);
  35.         String s = b.readLine ();
  36.         while (s != null) {
  37.         d.add (Double.parseDouble (s));
  38.         s = b.readLine ();
  39.         }
  40.         b.close();
  41.     }
  42.     catch (Exception e) {
  43.         e.printStackTrace ();
  44.     }
  45.     double [] num = new double [d.size ()];
  46.     for (int i = 0; i < d.size (); i++) {
  47.         num [i] = d.get (i);
  48.     }
  49.     return num;
  50.     }
  51.    
  52.     public static String [] readStrings (String filename) {
  53.     ArrayList<String> w = new ArrayList<String> ();
  54.    
  55.     try {
  56.         File f = new File (filename);
  57.         FileReader r = new FileReader (f);
  58.         BufferedReader b = new BufferedReader (r);
  59.         String s = b.readLine ();
  60.         while (s != null) {
  61.         w.add (s);
  62.         s = b.readLine ();
  63.         }
  64.         b.close();
  65.     }
  66.     catch (Exception e) {
  67.         e.printStackTrace ();
  68.     }
  69.    
  70.     String [] ws = new String [w.size ()];
  71.     for (int i = 0; i < w.size (); i++) {
  72.         ws [i] = w.get (i);
  73.     }
  74.    
  75.     return ws;
  76.     }
  77.    
  78.     public static void writeIntegersToFile (String filename, int [] num) {
  79.     try {
  80.         File f = new File (filename);
  81.         FileWriter w = new FileWriter (f);
  82.         BufferedWriter b = new BufferedWriter (w);
  83.         for (int i = 0; i < num.length; i++) {
  84.         b.write (num [i] + "\n");
  85.         }
  86.         b.close ();
  87.        
  88.     }
  89.     catch (Exception e) {
  90.         e.printStackTrace ();
  91.     }
  92.     }
  93.    
  94.     public static void writeDoublesToFile (String filename, double [] d) {
  95.     try {
  96.         File f = new File (filename);
  97.         FileWriter w = new FileWriter (f);
  98.         BufferedWriter b = new BufferedWriter (w);
  99.         for (int i = 0; i < d.length; i++) {
  100.         b.write (d [i] + "\n");
  101.         }
  102.         b.close ();
  103.        
  104.     }
  105.     catch (Exception e) {
  106.         e.printStackTrace ();
  107.     }
  108.     }
  109.    
  110.     public static void writeStringsToFile (String filename, String [] words) {
  111.     try {
  112.         File f = new File (filename);
  113.         FileWriter w = new FileWriter (f);
  114.         BufferedWriter b = new BufferedWriter (w);
  115.         for (int i = 0; i < words.length; i++) {
  116.         b.write (words [i] + "\n");
  117.         }
  118.         b.close ();
  119.        
  120.     }
  121.     catch (Exception e) {
  122.         e.printStackTrace ();
  123.     }
  124.    
  125.     }
  126.    
  127.     public static int [] ReadIntegerFile()
  128.     {// Read integers
  129.     int [] getallen = readIntegers ("getallen.txt");
  130.     for (int i = 0; i < getallen.length; i++) {
  131.         System.out.println (getallen [i]);
  132.     }
  133.     return getallen;
  134.     }
  135.    
  136.     public static double [] ReadDoubleFile()
  137.     {// Read doubles
  138.         double [] d = readDoubles ("doubles.txt");
  139.         for (int i = 0; i < d.length; i++) {
  140.             System.out.println ("d [" + i + "] = \"" + d [i] + "\"");
  141.         }
  142.         return d;
  143.     }
  144.    
  145.     public static String [] ReadWordFile()
  146.     {   // Read strings
  147.         String [] woorden = readStrings ("words.txt");
  148.         for (int i = 0; i < woorden.length; i++) {
  149.             System.out.println ("woord [" + i + "] = \"" + woorden [i] + "\"");
  150.         }
  151.         return woorden;
  152.     }
  153.    
  154.     public static void main (String [] args) {
  155.    
  156.  // Declaration of Variables to be used
  157.     int [] numbers;
  158.     double [] realnumbers;
  159.     String [] words;
  160.    
  161.  
  162.  // Read Input Files
  163.  //   numbers =readIntegers("getallen.txt");
  164.  //   realnumbers =readDoubles("doubles.txt");
  165.  //   words = readStrings("TEST.txt");
  166.    
  167.  //MAIN
  168.       //WRITE YOUR NEW PROGRAM HERE
  169.  
  170.  
  171.  
  172.  
  173. // Write integers, words and doubles to output files
  174. //writeStringsToFile ("newwords.txt", words);
  175. //writeIntegersToFile ("newintegers.txt", numbers);
  176. //writeDoublesToFile ("newdoubles.txt", realnumbers);
  177.    
  178.    
  179.     }
  180. }
Add Comment
Please, Sign In to add comment