JAvaのIOストリームとマルチスレッド

1.fileでディレクトリとファイルを操作する方法
JAvaはディレクトリとファイルに対してfileを統一的に使用し,fileオブジェクトを作成する際にisDictionaryとisFileメソッドを用いて判断する.

 1 package test;
 2 
 3 import java.io.File;
 4 
 5 import java.io.IOException;
 6 
 7 public class FileTest {
 8 
 9 public static void main(String[] args) {
10 
11 // TODO Auto-generated method stub
12 
13 File file1 = new File("E:/a.txt");
14 
15 if (!file1.exists()) {
16 
17 try {
18 
19 file1.createNewFile();
20 
21 } catch (IOException e) {
22 
23 // TODO Auto-generated catch block
24 
25 e.printStackTrace();
26 
27 System.out.println("      ！");
28 
29 }
30 
31 }
32 
33 //       
34 
35 File dir = new File("E:/testxjq");
36 
37 //        
38 
39 if (dir.isDirectory()) {
40 
41 //        
42 
43 String[] files = dir.list();
44 
45 for (String fileName : files) {
46 
47 //          File  
48 
49 File f = new File(dir.getPath() + File.separator + fileName);
50 
51 //     File        
52 
53 if (f.isFile()) {
54 
55 System.out.println("   ：" + f.getName());
56 
57 } else if (f.isDirectory()) {
58 
59 System.out.println("   ：" + f.getName());
60 
61 }else{
62 
63 System.out.println("null");
64 
65 }
66 
67 }
68 
69 }
70 
71 else{
72 
73 System.out.println("dsddssf");
74 
75 }
76 
77 }
78 
79 }

 
まとめ:FIleクラスの一般的な方法:
(1)構築方法:文字列形式のファイルパスを渡す方法でfileオブジェクトを作成し、fileはディレクトリやファイルがすでに存在するかどうかをチェックしません.
(2)IsDirectoryメソッドとisFileメソッドは,Fileオブジェクトがディレクトリであるか通常のファイルであるかを判断するために用いられる.
(3)fileオブジェクトに格納されたパスとファイル名を用いて作成するcreateNewFileメソッド.
(4)リストメソッド,ディレクトリ用,ディレクトリ下のすべてのファイル名,タイプ文字列配列を得る
(5)getName():彼のパスを含まないファイル名を取得します.
(6)Delete,ファイルの削除
2.ファイルをコピーするプログラムを書きますか?

 1 package test;
 2 
 3 import java.io.FileInputStream;
 4 
 5 import java.io.FileOutputStream;
 6 
 7 import java.io.IOException;
 8 
 9 public class FileCopy {
10 
11  
12 
13 public static void main(String[] args) throws IOException {
14 
15 // TODO Auto-generated method stub
16 
17 //             
18 
19 FileInputStream fin = new FileInputStream("e:/a.txt");
20 
21 //            
22 
23 FileOutputStream fout = new FileOutputStream("e:/b.txt");
24 
25 //           
26 
27 byte[] buff = new byte[256];
28 
29 //         
30 
31 int len = 0;
32 
33 while((len=fin.read(buff))>0){
34 
35 fout.write(buff, 0, len);
36 
37 }
38 
39 fin.close();
40 
41 fout.close();
42 
43 }
44 
45  
46 
47 }

 
 
3.ランダムアクセスファイルRandomAccessfileクラスの使用方法

 1 package test;
 2 
 3 import java.io.IOException;
 4 
 5 import java.io.RandomAccessFile;
 6 
 7 public class RanAccessFile {
 8 
 9  
10 
11 public static void main(String[] args) throws IOException {
12 
13 // TODO Auto-generated method stub
14 
15 //          
16 
17 RandomAccessFile file = new RandomAccessFile("E:/a.txt","rw");
18 
19 //  file    
20 
21 for(int i = 0;i){
22 
23 //            ，         ，      
24 
25 byte b  = (byte)file.read();
26 
27 char c  = (char)b;
28 
29 //        a
30 
31 if(c=='a'){
32 
33 //       
34 
35 file.seek(i);
36 
37 //        
38 
39 file.write('c');
40 
41 }
42 
43 }
44 
45 file.close();
46 
47 System.out.println("ok");
48 
49 }
50 
51 }

 
まとめ:lengthメソッドファイルのコンテンツ長を取得する
seekメソッドは、データへのアクセスが必要な場所をランダムに達成します.
readメソッドは現在位置のデータを取得し、writeメソッドはデータを書き込む
closeメソッドはファイルの開きを閉じます.
 
 
4.バイトストリームの処理方法
コンピュータ内部の処理データは常に1つのbyteを基本単位とし、バイトストリームは毎回読み出す単位byteであり、バイトストリームはすべてのストリームの基礎であり、他の高度なストリームの前提でもある.
JAvaのベースバイト入力ストリームと出力ストリームカテゴリ:
inputStreamとoutputStream
および:
FileInputStreamとFileOutputStream
ObjectInputStreamとObjectOutputStream
BufferedInputStreamとBufferedOutputStream
主にreadとwrite法によりbyte配列中のデータを書き込み読み出します.
5.文字ストリームの処理方法
文字ストリームはバイトストリームによって包装され、入出力ストリームのフォーマットは
StringReaderとStringWriter
BufferedReaderとBufferedWriter:特殊なReadLine()メソッド
例:

 1 package test;
 2 
 3 import java.io.BufferedReader;
 4 
 5 import java.io.FileInputStream;
 6 
 7 import java.io.IOException;
 8 
 9 import java.io.InputStream;
10 
11 import java.io.InputStreamReader;
12 
13 /*
14 
15  *           
16 
17  * */
18 
19 public class ReaderTest {
20 
21 public static void main(String[] args) throws IOException {
22 
23 // TODO Auto-generated method stub
24 
25 //           
26 
27 InputStream in = new FileInputStream("E:/a.txt");
28 
29 //  inputStreamReader  
30 
31 InputStreamReader isr = new InputStreamReader(in,"GBK");
32 
33 //       Reader  
34 
35 BufferedReader br = new BufferedReader(isr);
36 
37 //  StringBuffer          
38 
39 StringBuffer sb = new StringBuffer();
40 
41 String str = null;
42 
43  
44 
45 while((str = br.readLine())!=null){
46 
47 sb.append(str);
48 
49 }
50 
51 System.out.println("content:"+sb);
52 
53 br.close();
54 
55 isr.close();
56 
57 in.close();
58 
59 }
60 
61 }

 
6.シーケンス化とは?
JAvaオブジェクトの内村のデータは一連のバイナリデータに編成され、これらのデータを持続可能なデータ記憶装置に格納し、データを復元する必要がある場合、逆シーケンス化によりオブジェクトをメモリに再復元する.
JAva.io.Serializableインタフェースは、シーケンス化されたクラスのシンボルインタフェースであり、本省では、jvmのクラスのオブジェクトがシーケンス化できることを示す抽象的な方法はありません.シーケンス化idはserialVersionUID変数によって提供されます.
serialVersionUIDはクラスを判別するために用いられ,逆シーケンスの場合,2つのクラスのクラス名が同じであれば,そのidで判別する.
シーケンス化と逆シーケンス化を実現する例:

  1 package test;
  2 
  3 import java.io.FileInputStream;
  4 
  5 import java.io.FileNotFoundException;
  6 
  7 import java.io.FileOutputStream;
  8 
  9 import java.io.IOException;
 10 
 11 import java.io.ObjectInputStream;
 12 
 13 import java.io.ObjectOutputStream;
 14 
 15 import java.io.Serializable;
 16 
 17  
 18 
 19 class Person implements Serializable{
 20 
 21 public String getName() {
 22 
 23 return name;
 24 
 25 }
 26 
 27 public void setName(String name) {
 28 
 29 this.name = name;
 30 
 31 }
 32 
 33 public int getAge() {
 34 
 35 return age;
 36 
 37 }
 38 
 39 public void setAge(int age) {
 40 
 41 this.age = age;
 42 
 43 }
 44 
 45 //   id
 46 
 47 private static final long serialVersionUID = 1L;
 48 
 49 private String name;
 50 
 51 private int age;
 52 
 53 }
 54 
 55 public class SerialTest {
 56 
 57 public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
 58 
 59 // TODO Auto-generated method stub
 60 
 61 Person stu = new Person();
 62 
 63  
 64 
 65 stu.setAge(20);
 66 
 67 stu.setName("admin");
 68 
 69 //        ,        
 70 
 71 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("e:/a.dat"));
 72 
 73 //     
 74 
 75 oos.writeObject(stu);
 76 
 77 oos.close();
 78 
 79 //        
 80 
 81 ObjectInputStream ois = new ObjectInputStream(new FileInputStream("e:/a.dat"));
 82 
 83 //        ，        
 84 
 85 Person p = (Person)ois.readObject();
 86 
 87 //  
 88 
 89 System.out.println(p.getAge());
 90 
 91 System.out.println(p.getName());
 92 
 93 }
 94 
 95 }
 96 
 97   ：
 98 
 99 20
100 
101 admin

7.マルチスレッドとは?
プロセスはプログラム全体または一部のプログラムの動的実行であり、スレッドは命令のセットであり、プログラム内で単独で実行することができる.マルチスレッドは、プログラム内で複数の命令ストリームを同時に実行することを可能にするメカニズムであり、各命令ストリームは1つのスレッドと呼ばれ、互いに独立している.
メリット:
<1>スレッドを使用すると,長い時間を占めるプログラム内のタスクをバックグラウンドに配置して処理することができる.
＜2＞プログラムの実行速度を速める
<3>待機中のタスクの下で、スレッドは、消費されたメモリなどのリソースを解放することができます.
8.プロセスとスレッドの違い
<1>スレッドの分割スケールはプロセスより小さく、スレッドはプロセスに属する
<2>プロセスはプログラムの動的形式であり,CPU,メモリなどのリソース占有の基本単位であり,スレッドはこれらのリソースを独立して所有することはできない.
<3>スレッド間でメモリ領域を共有するので、通信が便利です.
<4>プロセスは、実行中に比較的固定されたエントリ、実行順序、およびエクスポートを含み、スレッドのこれらのプロセスはアプリケーションによって制御されます.
9.クラスをスレッドクラスにするにはどうすればいいですか?
方法一:java.lang.Runableインタフェースを実現する
メソッド2:java.lang.Threadクラスから継承
本質的には、ThreadおよびRunableインタフェースが実装されており、Threadクラスを継承する際にRunableインタフェースが実装されていますが、Threadクラスは追加の方法を提供しています.

 1 package test;
 2 
 3 public class RunTest implements Runnable {
 4 
 5 @Override
 6 
 7 public void run() {
 8 
 9 // TODO Auto-generated method stub
10 
11 System.out.println("thread running");
12 
13 }
14 
15 }
16 
17  
18 
19 package test;
20 
21 public class RunTest extends Thread {
22 
23 @Override
24 
25 public void run() {
26 
27 // TODO Auto-generated method stub
28 
29 System.out.println("thread running");
30 
31 }
32 
33 }

 
10.RunnableインタフェースとThreadクラスの違いは?
<1>スレッドクラスがThreadクラスを継承している場合、Javaは単一継承をサポートするため、他のクラスを継承することはできません.Runnableインタフェースは可能です.
<2>多くのスレッドを使用する場合は、Threadの方が便利です.
<3>Runnableインタフェースを実装するスレッドクラスの複数のスレッドは,同一変数により容易にアクセスできる.
 
11.スレッドを起動するにはどうすればいいですか?
Threadクラスから継承され、Runnableインタフェースが実装されました.

 1 package test;
 2 
 3 class ThreadTest extends Thread{
 4 
 5 public void run(){
 6 
 7 System.out.println("   Thread ");
 8 
 9 }
10 
11 }
12 
13 class RunnableTest implements Runnable{
14 
15 public void run(){
16 
17 System.out.println("   runnable  ");
18 
19 }
20 
21 }
22 
23  
24 
25 public class ThreadStartTest {
26 
27 public static void main(String[] args) {
28 
29 //     Thread ,    Thread   
30 
31 ThreadTest t1 = new ThreadTest();
32 
33 //t1  
34 
35 t1.start();
36 
37 //            ，          Thread        
38 
39 Thread t2 = new Thread(new RunnableTest());
40 
41 t2.start();
42 
43 }
44 
45 }

 
12.sychronizedを使用してスレッドを同期する方法
動作原理:各オブジェクトにはスレッドロックがあり、sychronizedは任意のオブジェクトのスレッドロックを使用してコードをロックすることができます.このセグメントコードにアクセスするスレッドは、ロックを解除してから続行する必要があります.そうしないと、待機状態になります.そのうち待機状態に入ります.

 1 package test;
 2 
 3 class Test extends Thread{
 4 
 5 public static int index;
 6 
 7     //              
 8 
 9 public static Object obj = new Object();
10 
11 public void run(){
12 
13 synchronized (obj) {
14 
15 for(int i =0;i<10;i++){
16 
17 System.out.println(index++);
18 
19 }
20 
21 }//end of synchronized
22 
23 }
24 
25 }
26 
27  
28 
29 public class MyThread {
30 
31 public static void main(String[] args) {
32 
33 // TODO Auto-generated method stub
34 
35 new Test().start();
36 
37 new Test().start();
38 
39 new Test().start();
40 
41 }
42 
43 }

13.スレッドプールの使用方法
コンポーネント:
1つのタスクを完了する1つ以上のスレッド.
スケジューリング管理用の管理スレッド;
実行を要求するタスクキュー;
目的:オブジェクトを最大限に多重化するために,スレッドを最大限に利用する.
14.反射の理解?
反射は動的機能を提供し、主に関連するAPIを反射することによって、属性、方法、コンストラクタを含む見知らぬjavaクラスのすべての情報を知ることができ、これらの要素は実行時に動的に作成または呼び出すことができ、JVMの実行時に決定する必要はありません.このクラスで作成されたjava.lang.Classクラスの例を使用します.
JAvaはclassクラスですべてのクラスを代表し、開発者がクラスの情報をコントロールするのに便利であり、1つのクラスの属性、方法などの情報を得たら、このclassを利用してインスタンスを作成し、任意の方法を呼び出し、任意の属性にアクセスすることができ、これが反射の主な用途である.
反射メカニズムのAPIは、主にjava.lang.reflectパッケージの下に集中しています.
15.class類の意味と役割は何ですか.
ステップ1:クラスはいつJVMにロードされますか?
<1>newキーワードでクラスのオブジェクトを使用
Student stu = new Student()
<2>クラスにアクセスする静的メンバー
Student.age;
<3>class.forName()メソッドを使用してロード
class.forName(“com.test.Student”);
第二布:クラスのclassオブジェクトをどのように取得しますか?
<1>Class.forName()メソッド
 
<2>アクセスクラスのclassプロパティ
 
<3>オブジェクトを作成し、オブジェクトのgetClass()メソッドを呼び出します.
 
16.クラスのメンバー変数をどのように操作しますか?field
反射式はクラスのオブジェクトを取得することができ、オブジェクトによってメンバー変数を取得することができます.
メソッド:getDeclareField()メソッドまたはgetDeclareFields()メソッドで取得します.
例:

 1 package test;
 2 
 3 import java.lang.reflect.Field;
 4 
 5 //   
 6 
 7 class Teacher{
 8 
 9 public Teacher(String name, int age) {
10 
11 super();
12 
13 this.name = name;
14 
15 this.age = age;
16 
17 }
18 
19 //            
20 
21 String name;
22 
23 int age;
24 
25 }
26 
27 public class FieldTest {
28 
29 public static void main(String[] args) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
30 
31 Teacher t1 = new Teacher("admin",23);
32 
33 Teacher t2 = new Teacher("   ",52);
34 
35 System.out.println(compare(t1,t2).name+"'s age is bigger!");
36 
37 }
38 
39 //                  
40 
41 @SuppressWarnings("unused")
42 
43 private static Teacher compare(Teacher tea1,Teacher tea2) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException{
44 
45 //     ：     getClass()      class  
46 
47 Field field  = tea1.getClass().getDeclaredField("age");
48 
49 //     ：    class         class  
50 
51 field = Teacher.class.getDeclaredField("age");
52 
53 //       age 
54 
55 int val1 = (int) field.get(tea1);
56 
57 int val2  = (int) field.get(tea2);
58 
59 //    
60 
61 if(val1>val2){
62 
63 return tea1;
64 
65 }else{
66 
67 return tea2;
68 
69 }
70 
71 }//end of compare
72 
73 }

17.クラスを反射操作する方法Method?

 1 package test;
 2 
 3 import java.lang.reflect.InvocationTargetException;
 4 
 5 import java.lang.reflect.Method;
 6 
 7  
 8 
 9 class MethodTestClass {
10 
11 public void m1() {
12 
13 System.out.println("m1 is called!");
14 
15 }
16 
17  
18 
19 public void m2() {
20 
21 System.out.println("m2 is called");
22 
23 }
24 
25 }
26 
27  
28 
29 public class CallMethodTest {
30 
31  
32 
33 public static void main(String[] args)
34 
35 throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
36 
37 // TODO Auto-generated method stub
38 
39 args = new String[] { "m1" };
40 
41 //      
42 
43 String methodName = args[0];
44 
45 if (methodName != null) {
46 
47 //   class  
48 
49 Class clazz = MethodTestClass.class;
50 
51 //           
52 
53 Method m = clazz.getDeclaredMethod(methodName);
54 
55 //     ，       ，         
56 
57 if (m != null) {
58 
59 MethodTestClass obj = clazz.newInstance();
60 
61 //   m       ，       
62 
63 m.invoke(obj);
64 
65 }
66 
67 }
68 
69 }
70 
71 }
72 
73  
74 
75  

18.反射を利用してクラスをインスタンス化しますか?
2つのケース:
<1>パラメータなしのデフォルトの額構築方法:
ClassクラスのnewInstance()メソッド
<2>パラメータのある構造方法:
まずconstructorインスタンスを取得し、newInsance()メソッドでオブジェクトを作成します.
例:

  1 package test;
  3 import java.lang.reflect.Constructor;
  5 import java.lang.reflect.InvocationTargetException;
  9 class people{
 11 public String getName() {
 13 return name;
 15 }
 17 public void setName(String name) {
 18 
 19 this.name = name;
 20 
 21 }
 22 
 23 public int getAge() {
 25 return age；
 27 }
 28 
 29 public void setAge(int age) {
 31 this.age = age;
 33 }
 34 
 35 @Override
 36 
 37 public String toString() {
 38 
 39 return "people [name=" + name + ", age=" + age + "]";
 40 
 41 }
 42 
 43 public people() {
 45 super();
 46 
 47 // TODO Auto-generated constructor stub
 48 
 49 }
 50 
 51 public people(String name, int age) {
 52 
 53 super();
 54 
 55 this.name = name;
 56 
 57 this.age = age;
 58 
 59 }
 60 
 61 private String name;
 62 
 63 private int age;
 64 
 65 }
 66 
 67  
 68 
 69 public class NewInstanceTest {
 70 
 71  
 72 
 73 public static void main(String[] args) throws InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
 74 
 75 // TODO Auto-generated method stub   
 76 
 77 //step1:  Class  
 78 
 79     Class clazz =   people.class;
 80 
 81     //step2:   ：          
 82 
 83     //class        
 84 
 85 people obj = clazz.newInstance();
 86 
 87 System.out.println("     ："+obj);
 88 
 89  
 90 
 91  
 92 
 93 obj.setName("xsxs");
 94 
 95 obj.setAge(50);
 96 
 97 System.out.println("  get/set      ："+obj.getName());
 98 
 99 System.out.println("  get/set      ："+obj.getAge());
100 
101  
102 
103  
104 
105 //step3:   ：          
106 
107 //          
108 
109 Constructor con = clazz.getConstructor(String.class,int.class);
110 
111 obj = con.newInstance("admin",30);
112 
113 System.out.println("     ："+obj);
114 
115 }
116 
117 }

 
19.反射を使用してプライベートメンバーにアクセスする方法

 1 package test;
 2 
 3 import java.lang.reflect.Field;
 4 
 5 class PrivateTestClass{
 6 
 7 //      
 8 
 9 public PrivateTestClass(String field) {
10 
11 super();
12 
13 this.field = field;
14 
15 }
16 
17 private String field;//         
18 
19 }
20 
21 public class PrivateTest {
22 
23 public static void main(String[] args) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
24 
25 // TODO Auto-generated method stub
26 
27 //        
28 
29 PrivateTestClass ptc = new PrivateTestClass("hello");
30 
31 //       Class  
32 
33 Class clazz = ptc.getClass();
34 
35 //              
36 
37 Field myprivatefield = clazz.getDeclaredField("field");
38 
39 //       true
40 
41 myprivatefield.setAccessible(true);
42 
43 //get     Field          
44 
45 System.out.println(myprivatefield.get(ptc));
46 
47 }
48 
49 }

 
20.反射によってデータ・オブジェクトのtoString()メソッドを上書きする方法
作成された背景:
クラスで属性名を変更し、新しい属性を追加し、属性を削除する場合は、toStringメソッドでも一部の属性を再追加または削除します.

  1 package test;
  2 import java.lang.reflect.Field;
  3 class DataObject{
  4 public String getName() {
  5 
  6 return name;
  7 
  8 }
  9 
 10 public void setName(String name) {
 11 
 12 this.name = name;
 13 
 14 }
 15 
 16 public int getAge() {
 17 
 18 return age;
 19 
 20 }
 21 
 22 public void setAge(int age) {
 23 
 24 this.age = age;
 25 
 26 }
 27 
 28 public DataObject() {
 29 
 30 super();
 31 
 32 // TODO Auto-generated constructor stub
 33 
 34 }
 35 
 36 public DataObject(String name, int age) {
 37 
 38 super();
 39 
 40 this.name = name;
 41 
 42 this.age = age;
 43 
 44 }
 45 
 46 //          
 47 
 48 private String name;
 49 
 50 private int age;
 51 
 52 //        ToString  
 53 
 54 public String toString(){
 55 
 56 //    StringBuffer      
 57 
 58 StringBuffer sb = new StringBuffer();
 59 
 60 //             fields
 61 
 62 Field[] fields = this.getClass().getDeclaredFields();
 63 
 64 //    
 65 
 66 for(Field f:fields){
 67 
 68 //        
 69 
 70 sb.append(f.getName());
 71 
 72 //   ==
 73 
 74 sb.append("=");
 75 
 76 //      
 77 
 78 try {
 79 
 80 sb.append(f.get(this));
 81 
 82 } catch (IllegalArgumentException e) {
 83 
 84 // TODO Auto-generated catch block
 85 
 86 e.printStackTrace();
 87 
 88 } catch (IllegalAccessException e) {
 89 
 90 // TODO Auto-generated catch block
 91 
 92 e.printStackTrace();
 93 
 94 }
 95 
 96 //         ，    /    
 97 
 98 sb.append(" ");
 99 
100 }
101 
102 //         
103 
104 return sb.toString();
105 
106 }//end of toString()
107 
108 }
109 
110 public class DataObjectTest {
111 public static void main(String[] args) throws InstantiationException, IllegalAccessException {
112 
113 // TODO Auto-generated method stub
114 
115 //             
116 
117 DataObject obj = new DataObject();
118 
119     @SuppressWarnings("unchecked")
120 
121 Class clazz  = (Class) obj.getClass();
122 
123     DataObject my  =  clazz.newInstance();
124 
125     //           
126 
127     my.setAge(100);
128 
129     my.setName("dddddd");
130 
131     //     ，      toString  
132 
133 System.out.println(my);
134 
135 }
136 }