BA

package Board;

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

public class board {
    private Scanner s;
    private List<String[]> bbsList;

    private int seq;

    public board() {
        this.s = new Scanner(System.in);
        this.bbsList = new ArrayList<String[]>();

        this.seq = 1;
    }

    public void readme() {
        System.out.println("1. 등록,   2, 상세보기.    3. 수정    4. 삭제");
    }

    public void exit() {
        System.out.println("프로그램을 종료합니다");
    }

    public String getInput() {
        return this.s.next();
    }

    public void create() {
        String no = String.valueOf(seq);

        System.out.println("input title...");
        String title = getInput();

        System.out.println("Input content...");
        String content = getInput();

        String[] bbs = new String[3];
        bbs[0] = no;
        bbs[1] = title;
        bbs[2] = content;

        this.bbsList.add(bbs);

        this.seq++;

        System.out.println("등록이 완료 되었습니다");

    }

    private String[] getSearch(String no) {
        for (String[] bbs : this.bbsList) {
            if (bbs != null && bbs[0].equals(no)) {
                return bbs;
            }
        }
        return null;
    }

    public void read(String no){
        if(no==null|| no==""){
            System.out.println("잘못 입력 하셨습니다. ");
            return;
        }
       
        String[] bbs=this.getSearch(no);
       
        if(bbs==null){
            System.out.println("게시글이 없습니다. ");
            return;
        }
       
        System.out.println("no : "+bbs[0]);
        System.out.println("title : "+bbs[1]);
        System.out.println("content : "+ bbs[2]);
    }
   
    public void update (String no){
        if(no==null|| no==""){
            System.out.println("잘못 입력하셨습니다.");
            return ;
        }
       
        String[] bbs=this.getSearch(no);
       
        if(bbs==null){
            System.out.println("게시글이 없습니다. ");
            return;
        }
       
        System.out.println("input title ...");
        String title=this.getInput();
       
        System.out.println("input content...");
        String content=this.getInput();
       
        bbs[1]=title;
        bbs[2]=content;
       
        System.out.println("수정이 완료 되었습니다.");
    }
   
    public void delete(String no){
        if(no==null||no==""){
            System.out.println("잘못 입력 하셨습니다.");
            return;
        }
       
        String[] bbs=this.getSearch(no);
       
        if(bbs==null){
            System.out.println("게시글이 없습니다. ");
            return;
        }
       
        this.bbsList.remove(bbs);
        System.out.println("삭제가 완료 되었습니다");
    }
   
    public void getList(){
        for(String[] bbs: this.bbsList){
            if(bbs!=null){
                System.out.println("no : "+ bbs[0]);
                System.out.println("title : "+ bbs[1]);
                System.out.println("content : "+ bbs[2]);
            }
        }
    }
   
    public static void main(String[] args){
       
        board bbs=new board();
       
        while(true){
            bbs.readme();
           
            String choice =bbs.getInput();
           
            if(choice.equals("1")){
                bbs.create();
            }else if(choice.equals("2")){
                System.out.println("번호를 입력하세요 ");
                bbs.read(bbs.getInput());
            }else if(choice.equals("3")){
                System.out.println("번호를 입력하세요");
                bbs.update(bbs.getInput());
            }else if(choice.equals("4")){
                System.out.println("번호를 입력하세요");
                bbs.delete(bbs.getInput());
            }else if(choice.equals("5")){
                bbs.getList();
            }else if(choice.equals("x")){
                bbs.exit();
                break;
            }else {
                System.out.println("잘못 입력하셨습니다. \n 다시 입력해 주세요 ");
            }
        }
    }
}

package FileReader;

import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;

public class GuiFindAll {
    final static String LINE_SEPARATOR=System.getProperty("line.separator");
    static JTextArea txtSrchResults;
    static JFrame f;
    static volatile String result;
    static JPanel createGUI(){
        JPanel pnl=new JPanel();
        pnl.setLayout(new BoxLayout(pnl, BoxLayout.Y_AXIS));
        JPanel pnlTemp=new JPanel();
        JLabel lblStartDir=new JLabel("Start directory");
        pnlTemp.add(lblStartDir);
        final JTextField txtStartDir=new JTextField(30);
        pnlTemp.add(txtStartDir);
        pnl.add(pnlTemp);
        pnlTemp=new JPanel();
        JLabel lblSrchText=new JLabel("Search text");
        pnlTemp.add(lblSrchText);
        lblSrchText.setPreferredSize(lblStartDir.getPreferredSize());
        final JTextField txtSrchText=new JTextField(30);
        pnlTemp.add(txtSrchText);
        pnl.add(pnlTemp);
        pnlTemp=new JPanel();
        JButton btnSearch=new JButton("Search");
        pnlTemp.add(btnSearch);
        pnl.add(pnlTemp);
        pnlTemp=new JPanel();
        txtSrchResults=new JTextArea(20,30);
        pnlTemp.add(new JScrollPane(txtSrchResults));
        pnl.add(pnlTemp);
        ActionListener al;
        al=new ActionListener() {
           
            @Override
            public void actionPerformed(ActionEvent e) {
                final String startDir=txtStartDir.getText();
                final String srchText=txtSrchText.getText();
                txtSrchResults.setText("");
                Runnable r;
                r=new Runnable() {
                   
                    @Override
                    public void run() {
                        if(!findAll(new File(startDir),srchText)){
                            Runnable r=new Runnable() {
                               
                                @Override
                                public void run() {
                                    String msg="not a directory";
                                    JOptionPane.showMessageDialog(f, msg);
                                }
                            };
                            EventQueue.invokeLater(r);
                        }
                    }
                };
                new Thread(r).start();
            }
        };
        btnSearch.addActionListener(al);
        return pnl;
    }

    static boolean findAll(File file, String srchText){
        File[] files=file.listFiles();
        if(files==null)
            return false;
        for(int i=0;i<files.length;i++)
            if(files[i].isDirectory())
                findAll(files[i],srchText);
            else
                if(find(files[i].getPath(),srchText)){
                    result=files[i].getPath();
                    Runnable r=new Runnable() {
                       
                        @Override
                        public void run() {
                            txtSrchResults.append(result+LINE_SEPARATOR);
                        }
                    };
                    EventQueue.invokeLater(r);
                }
            return true;
    }

    static boolean find(String filename, String srchText){
        try(BufferedReader br=new BufferedReader(new FileReader(filename))) {
            int ch;
            outer_loop:
            do{
                if((ch=br.read())==-1)
                    return false;
                if(ch==srchText.charAt(0)){
                    for(int i=1;i<srchText.length();i++){
                        if((ch=br.read())==-1)
                            return false;
                        if(ch!=srchText.charAt(i))
                            continue outer_loop;
                    }
                    return true;
                }
            }
            while(true);
           
        } catch (IOException ioe) {
                System.err.println("I/O error : "+ ioe.getMessage());
        }
        return false;
    }
    public static void main(String[] args){
        Runnable r=new Runnable() {
           
            @Override
            public void run() {
                f=new JFrame("FindAll");
                f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                f.setContentPane(createGUI());
                f.pack();
                f.setResizable(false);
                f.setVisible(true);
            }
        };
        EventQueue.invokeLater(r);
    }
}

=============

FindAll클래스에서는 createGUI(), findAll(), find() 그리고 main() 클래스 메소드와 함께 여러 개의 클래스 필드를 선언하고 있다. FindAll은 멀티 스레드 애플리케이션이다. 메인 스레드는 main()을 실행만 시키고 FindAll의 GUI는 EDT(event-dispatch thread)에서 실행이 되고 findAll()메소드를 실행하는 워커 스레드를 생성한다.

특정 시점에 스레드는 공유된 변수들 (shared variables)과 커뮤니케이션해야 하는데 이런 커뮤니케이션은 동기화 문제를 발생시킬 수 ㅇ씨다. 이런 동기화 문제를 피하기 위해 위의 예제에서는 volatile result 필드를 생성했으며 final 로컬 변수들을 사용한다.

result 필드를 volatile로 선언했기 때문에 멀티코어 또는 멀티 프로세서 플랫폼 상에서도 각각의 코어 또는 프로세서가 이 필드의 복사본을 갖고 있기 때문에 EDT와 워커 스레드에서 result의 String 참도 값을 확인 할 수 있다. 만일 result가 volatile로 선언되어 있지 않으면 EDT에서는 findAll() 메소드에서 일치하는 문자를 찾았을 때 새로운 String 객체가 할당된 result의 참도를 볼 수 없을 것이다( 싱글 프로세서 또는 싱글 코어 플랫폼에서는 이런 문제가 발새하지 않는다)

위와 같은 이유로 startDir와 srchText 로컬 변수를 가지고 있지만 이 로컬 변수들은 volatile이 아닌 final로 선언되어 있다. 이 러컬 변수들은 final로 선언되어 있어야 검색 버튼의 액션 리스너 내의 java.lang.Runnable로 구현된 익명 클래스에서 접근이 가능하다.

결과적으로 final 필드에 대해서는 volatile 선언이 필요하지 않으며 한 필드에 대해 volatile과 final을 동시에 지정을 할 수는 없다. final 필드는 안전하게 접근할 수는 있지만, 반드시 final 참조 필드를 참조하는 객체가 필요하지는 않다. String 객체는 불변이기 때문에 startDir, srchText 그리고 result에서 String 메소드를 호출해도 문제가 발생하지 않는다.

검색 버튼에서 액션 리스너는 runnable내에서 runnable을 선언하고 있어 코드가 복잡해 보이는데 다음은 이 코드들이 어떻게 동작하는지를 단계별로 소개한다.

1. 사용자가 검색 버튼을 누르면 actionPerformed()메소드가 호출된다.

2. actionPerformed() 메소드에서는 검색을 시작할 디렉터리와 검색할 문자를 텍스트 필드에서 가지고 온 후 새로운 검색 결과를 보여주기 위해 텍스트 영역을 " " 로 초기화 한다. 다음, runnable을 생성하고 EDT에서 워커 스레드를 실행한다.

3. 다음, 작업 스레드는 run()메소드 호출을 통해 runnable을 실행할 것이다.

4. run()에서는 검색을 시작하기 위해 findAll()메소드를 호출한다. 만일 finaAll()이 false를 반환하면 javax.swing.JOptionPane 기반의 다이얼로그 박스를 통해 에러 메시지를 출력하는 새로운 runnable이 생성된다. 워커 스레드는 EDT에 다이얼로그 박스에 보여주기 위해 javax.awt.EventQueue의 invokeLater() 메소드를 실행한다.

다음과 같은 코드를 볼 수 있다.

pnl.setLayout (new BoxLayout (pnl, BoxLayout.Y_AXIS));

이 코드는 컨테이너의 컴포넌트를 배치하기 위해 스윙의 javax.swing.BoxLayout 클래스를 사용하는 것이다. java.awt.GridLayout와는 달리 BoxLayout 은 컴포넌트들에게 같은 크기를 지정하지 않는다. 검색 결과가 많이 반환 될 수 있으므로 텍스트 영역은 스크롤이 가능해야 한다. 하지만 이 컴포넌트는 기본적으로 스크롤을 지원하지 않으므로 스크롤을 지원하기 위해 scrollpane을 추가해야 하는데 javax.swing.JScrollPane 클래스를 사용하여스크롤을 지원할 수 있다.

JScrollPane은 스크롤이 추가될 컴포넌트와 함께 호출되는 생성자를 제공하는데 예를 들어 JScrollPane(Component view) 형식의 생성자를 제공한다. 이와는 대조적으로 AWT의 java.awt.ScrollPane 클래스는 add() 메소드를 사용해 스크롤을 지원할 컴포넌트를 전달한다.

정리

많은 애플리케이션에서 파일에 데이터를 저장하거나 파일로부터 데이터를 읽어 오기 위해 파일시스템과 상호 작용을 한다. 자바의 표준 클래스 라이브러리에서는 File, RandomAccessFile, 스트림 그리고 writer/reader API를 통해 파일 시스템에 접근을 제공한다.

자바는 플랫폼 하부의 파일시스템에 접근할 수 있는 FIle 실제 클래스를 제공하는데 File 인스턴스는 파일 또는 디렉터리의 추상 경로명을 포함하고 있다.

파일들은 읽기/쓰기를 같이 사용할 수 있는 임의 접근 형식으로 오픈될 수 있는데 자바에서는 이런 임의 접근(random access)을 RandomAccessFile 클래스를 통해 지원한다.

자바는 I/O 작업을 수행하기 위해 스트림을 사용한다. 스트림은 임의의 길이를 가지는 바이트들의 시퀸스를 의미한다. 바이트들은 애플리케이션으로부터 출력 스트림을 통해 목적지로 전달되며 소스에서 입력 스트림을 통해 애플리케이션으로 전달된다.

java.io 패키지에서는 OutputStream과 InputStream 추상 클래스로부터 파생된 여러가지 출력 스트림과 입력 스트림을 제공한다. FileOutputStream와 BufferedInputStream이외에도 여러가지 스트림 서브 클래스들이 제공된다.

자바의 스트림 클래스는 바이트의 시퀸스를 스트림하기에 적합하지만 바이트 스트림은 문자 셋과 인코딩을 지원하지 못하기 때문에 문자의 시퀸스를 스트림하기에는 부적합하다. 문자에 대한 스트림이 필요하다면 문자 I/O를 지원하도록 설계된 자바의 쓰기와 읽기 클래스들을 사용해야 하는데 이런 클래스들은 문자 인코딩을 지원한다.

java.io 패키지에서 Writer와 Reader 추상 클래스로부터 파생된 여러가지 쓰기와 읽기 클래스를 제공한다. 대표적인 쓰기, 읽기 클래스로는 OutputStreamWriter, FileWriter, InputStreamReader, FileReader 그리고 BufferedReader 등이 있다.

많은 애플리케이션에서 파일시스템뿐만 아니라 네트워크 그리고 데이터베이스와 상호 작용을 한다.

package Scanner;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;

public class InsFileReader {
    public static void main(String argsp[]) throws IOException{
        int i;
        double d;
        boolean b;
        String str;
       
        FileWriter fout=new FileWriter("/scantest.txt");
        fout.write("Testing Scanner 10 12.2 one true two false");
        fout.close();
       
        FileReader fin=new FileReader("/scantest.txt");
       
        Scanner src=new Scanner(fin);
       
        while(src.hasNext()){
            if(src.hasNextInt()){
                i=src.nextInt();
                System.out.println("Int: "+i);
            }else if(src.hasNextDouble()){
                d=src.nextDouble();
                System.out.println("Double: "+d);
            }else if(src.hasNextBoolean()){
                b=src.nextBoolean();
                System.out.println("Boolean: "+b);
            }else{
                str=src.next();
                System.out.println("String: "+str);
            }
        }
        fin.close();
    }
}

1. 입력값을 지정된 구분 패턴 (구분자, Delimiter Pattern)으로 파싱할 수 있다.

2. 구분 패턴의 기본 값은 공백 문자, White space이다.

3. 파일, 스트림, 문자열을 원천 데이터로 사용할 수 있다.

4. 토큰들은 자동적으로 기본 데이터형으로 변경될 수 있다.

java.util.Scanner 생성자

Scanner(File source)  -  지정된 파일을 사용하는 Scanner객체를 생성한다.

Scanner(InputStream source)  -  지정된 입력 스트림을 사용하는 Scanner객체를 생성한다.

Scanner(String source)  -  지정된 문자열을 사용하는 Scanner 객체를 생성한다.

메소드

void close()  -  Scanner를 닫는다.

boolean hasNext()  -  입력값에 다른 토큰(token)이 존재한다면 true를 반환한다.

String next()  -  토큰을 찾은 다음 반환한다.

xxx

nextxxx  -  토큰을 xxx로 반환한다. (xxx에는 기본 데이터 형부터 (BigDecimal, BigInteger등이 올 수 있다)

Scanner

UseDelimiter(Pattern pattern)  -  지정된 패턴을 Scanner의 문자로 설정한다.

Scanner

UseDelimiter(String pattern)  -  지정된 문자열을 Scanner의 구분자로 설정한다.

============

package Scanner;

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

public class test {
    public static void main(String[] args){
        Scanner s=null;
        try {
            s=new Scanner(new File("/org.txt"));
            while(s.hasNext()){
                System.out.println(s.next());
            }
        } catch (IOException ioe) {
                ioe.printStackTrace();
        }finally{
            if(s!=null)
                s.close();
        }
    }
}

============

package Scanner;

import java.util.Scanner;

public class test2 {
    public static void main(String[] args){
        String input="scjp del java del A del 1";
        Scanner s=new Scanner(input).useDelimiter("\\s*del\\s*");
        System.out.println(s.next());
        System.out.println(s.next());
        System.out.println(s.next());
        System.out.println(s.nextInt());
        s.close();
    }
}

데이터를 객체 단위로 읽고 쓰는 클래스

java.io.ObjectInputStream 클래스의 생성자

ObjectInputStream(InputStream in)

지정된 InputStream에 대한 ObjectInputStream 객체를 생성한다.

메소드

int available()  -  입력 스트림에서 읽을 수 있는 바이트 수를 반환한다.

void close()  -  입력 스트림을 닫는다.

int read()  -  입력 스트림에서 1바이트 데이터를 읽는다

int read(byte[] buf, int off, int len)  -  입력 스트림에서 Object를 읽는다.

====

ObjectOutputStream 클래스

데이터를 객체 단위로 쓰기 위한 클래스

java.io.ObjectOutputStream클래스의 생성자

ObjectOutputStream(OutputStream in)

지정된 OutputStream에 대한 ObjectOutputStream을 생성한다.

메소드

void  flush()  -  버퍼링되어 아직 기록되지 않은 데이터를 출력 스트림에 모두 기록한다.

void  close()  -  입력 스트림을 닫는다.

void write(byte[] b)  -  b.length 바이트의 데이터를 출력 스트림에 기록한다.

void write(byte[] b, int off, int len)  -  지정된 바이트 배열의 off 위치부터 len 개 까지의 데이터를 출력 스르림에 기록한다.

void write(int b)  -  지정된 바이트를 출력 스트림에 기록한다.

void writeObject(Object obj)  -  입력 스트림에 Object 를 기록한다.

-=============

package ObjectStreamEx;

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

public class test {
    public static void main(String[] args) throws Exception{
        ObjectOutputStream os=new ObjectOutputStream(new FileOutputStream("/string.ser"));
       
        String inStr=new String("forcert");
       
        os.writeObject(inStr);
        os.close();
       
        ObjectInputStream is=new ObjectInputStream(new FileInputStream("/string.ser"));
        Object obj=is.readObject();
        is.close();
       
        String outstr=(String)obj;
       
        System.out.println(outstr);
     }
}

FileReader는 파일로부터 문자를 읽을 때 편리하게 사용되는 클래스이다. 이 클래스는 InputSreamReader의 서브 클래스이며 클래스의 생성자에서는 InputSreamReader의 InputStreamReader(InputSream)생성자를 호출한다. 이 클래스의 인스턴스에서는 다음 코드와 같은 작업을 수행한다.

FileInputStream fis=new FileInputSream(pathname);

InputStreamReader isr;

isr=new InputSteamReader(fis, System.getProperty("file.encoding"));

특정 문자열을 포함하고 있는 파일 찾기

package FileReader;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

class FindAll {
    public static void main(String[] args){
        if(args.length!=2){
            System.err.println("usage: java FindAll start search-string");
            return;
        }
        if(!findAll(new File(args[0]),args[1]))
            System.err.println("not a directory");
       
    }
   
    static boolean findAll(File file, String srchText){
        File[] files=file.listFiles();
        if(files==null)
            return false;
       
        for(int i=0;i<file.length();i++)
            if(files[i].isDirectory())
                findAll(files[i], srchText);
            else
                if(find(files[i].getPath(), srchText))
                    System.out.println(files[i].getPath());
           
        return true;
        }
       
       
    static boolean find(String filename, String srchText){
       
        try(BufferedReader br=new BufferedReader(new FileReader(filename))) {
            int ch;
            outer_loop:
            do{
                if((ch=br.read())==-1)
                    return false;
                if(ch==srchText.charAt(0)){
                    for(int i=1;i<srchText.length();i++){
                        if((ch=br.read())==-1)
                            return false;
                        if(ch!=srchText.charAt(i))
                            continue outer_loop;
                    }
                    return true;
                }
            }
            while(true);
           
        } catch (IOException ioe) {
                System.err.println("I/O error: "+ioe.getMessage());
        }
        return false;
    }
}
   
   
=========

FIndAll()클래스에서는 main(), findAll(), find() 클래스 메소드를 선언하고 있다.

main()에서는 두 개의 커맨드 라인 인자가 전달되었는지 확인하는데 첫 번째 인자에는 검색할 파일 시스템의 시작 위치를 지정하며 이 인자는 File 객체의 생성자에서 사용된다. 두 번째 인자는 검색할 텍스트가 지정되며 이 문자열이 포함된 파일들을 찾기 위해 File객체와 함께 findAll() 메소드로 전달된다.

재뒤 호출을 하는 findAll()메소드에서는 제일 먼저 File객체의 listFiles()메소드를 호출하여 현재 디렉터리에 있는 모든 파일들의 이름을 획득한다. 만일 listFiles() 메소드가 null을 반환하면 File 객체가 디렉터리를 참조하지 않는다는 의미이므로 findAll()은 false를 반환하고 적절한 에러 메시지를 출력한다.

리스트에서 반환되는 각각의 이름을 확인해서 반환된 이름이 디렉터리면 findAll()을 재귀호출하고 파일이면 지정한 문자열이 파일에 포함되어 있는지 확인하기 위해 BufferedReader 생성자에 전달하여 BufferedReader 인스턴스를 생성한다. 다음, 반복문을 통해 파일의 처음부터 파일의 끝에 도달할 때까지 문자들을 읽어들인다.

만일 현재 읽은 문자와 검색 텍스트의 첫번째 문자가 같으면 내부에 있는 반복문에서 나머지 문자들을 비교한다. 문자들이 일치하면 find() 메소드는 true를 반환하고 아니면 outer_loop 레이블로 이동하여 외부 반복문에서 다음 문자들의 비교를 시작한다. 마지막 문자를 읽을 때까지 일치하는 문자가 없으면 find()메소드는 false를 반환한다.

FileWriter 는 문자를 파일에 저장할 때 편리한 클래스이다. 이 클래스는 OutputStreamWriter의 서브 클래스로 이 클래스의 생성자에서는 OutputStreamWriter클래스의 생성자인 OutputStreamWriter(OutputStream)를 호출한다.

이 클래스의 생성자는 다음과 같은 작업을 수행한다.

FileOutputStream fos=new FileOutputStream(pathname);

OutputStreamWriter osw;

osw=new OutputStreamWriter(fos, System.getProperty("file.encoding"));

package ByteArrayInputStream;

import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.EOFException;
import java.io.IOException;

public class newByteArrayInputStream {
    public static void main(String[] args)throws IOException{
        try {
            DataInputStream in3=new DataInputStream(new ByteArrayInputStream("a bcdef".getBytes()));
            while(true){
                System.out.println((char)in3.readByte());
            }
        } catch (EOFException e) {
                System.err.println("End of stream");
        }
    }   
}

package BufferedWriter;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class flush00 {
    public static void main(String[] args) throws Exception{
        BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
        String strLine=in.readLine();
       
        BufferedWriter out=new BufferedWriter(new OutputStreamWriter(System.out));
        out.write(strLine,0,strLine.length());
        out.flush();
        in.close();
        out.close();
    }
}

package BufferedWriter;

import java.io.BufferedWriter;
import java.io.FileWriter;

public class close00 {
    public static void main(String[] args){
        try {
            FileWriter fw=new FileWriter("/filewriter.txt");
            BufferedWriter bw=new BufferedWriter(fw);
           
            for(int i=0;i<12;i++){
                bw.write("Line "+i+"\n");
            }
            bw.close();
        } catch (Exception e) {
                e.printStackTrace();
        }
    }
}