Java学习笔记（二）

1. JDK、JRE和JVM分别是什么，区别是什么？

答：

 

①、JDK 是整个Java的核心，包括了Java运行环境、Java工具和Java基础类库。

 

②、JRE（Java Runtime Environment，Java运行环境），运行JAVA程序所必须的环境的集合，包含JVM标准实现及Java核心类库。

 

③、JVM是Java Virtual Machine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。

 

2. 写一个冒泡法程序，给10个杂乱无章的数字，按照从小到大的顺序排列出来。

Java程序为：

 

 

class Java_Demo2 { 

    public static void main(String[] args) { 

        int[] a = {5,6,4,3,2,1,8,7,9,0}; 

        maoPao(a); 

    } 

    //冒泡排序法 

    public static void maoPao(int[] a){ 

        for(int i=0;i

            for(int j=i;j

                if(a[i]>a[j]){ 

                    int s = a[i]; 

                    a[i] = a[j]; 

                    a[j] = s; 

                } 

            } 

            System.out.print(a[i] + "\t"); 

        } 

        System.out.println(); 

    } 

} 

3. JDK1.7的新特性。

答：

 

1，switch中可以使用字串

 

Java代码：

 

 

String s = "test";    

switch (s) {    

  case "test" :    

     System.out.println("test");   

  case "test1" :    

    System.out.println("test1");  

    break ;    

  default :    

    System.out.println("break");  

    break ;    

 }   

2，"<>"这个玩意儿的运用List tempList = new ArrayList<>(); 即泛型实例化类型自动推断。

 

3. 语法上支持集合，而不一定是数组

 

Java代码：

 

 

final List piDigits = [ 1,2,3,4,5,8 ];  

4. 新增一些取环境信息的工具方法

 

Java代码：

 

 

File System.getJavaIoTempDir() // IO临时文件夹  

File System.getJavaHomeDir() // JRE的安装目录  

File System.getUserHomeDir() // 当前用户目录  

File System.getUserDir() // 启动java进程时所在的目录  

.......  

5. Boolean类型反转，空指针安全,参与位运算

 

Java代码：

 

 

Boolean Booleans.negate(Boolean booleanObj)  

True => False , False => True, Null => Null  

boolean Booleans.and(boolean[] array)  

boolean Booleans.or(boolean[] array)  

boolean Booleans.xor(boolean[] array)  

boolean Booleans.and(Boolean[] array)  

boolean Booleans.or(Boolean[] array)  

boolean Booleans.xor(Boolean[] array)  

6. 两个char间的equals

 

Java代码：

 

 

boolean Character.equalsIgnoreCase(char ch1, char ch2)  

7，安全的加减乘除

 

Java代码：

 

 

int Math.safeToInt(long value) 

int Math.safeNegate(int value) 

long Math.safeSubtract(long value1, int value2) 

long Math.safeSubtract(long value1, long value2) 

int Math.safeMultiply(int value1, int value2)  

long Math.safeMultiply(long value1, int value2) 

long Math.safeMultiply(long value1, long value2) 

long Math.safeNegate(long value) 

int Math.safeAdd(int value1, int value2) 

long Math.safeAdd(long value1, int value2) 

long Math.safeAdd(long value1, long value2) 

int Math.safeSubtract(int value1, int value2) 

4. switch语句能否作用在byte上，能否作用在long上，能否作用在String上。

答：在JDK1.6的版本中，switch后面的括号里面只能放int类型的值，注意是只能放int类型，但是放byte，short，char类型的也可以是因为byte，short，shar可以自动提升（自动类型转换）为int。而不能放long型和String型。

 

而在JDK1.7的版本中，switch中可以使用字串String。但仍不支持long型。

 

Example1：

 

 

String name = "b";    

switch(name) {   

    case "a":   

     System.out.println("String可以用于switch语句");   

        break;   

} //可以运行 

Example2：

 

 

long long_s = 22222;    

 switch (long_s) {    

 case 22222:    

 System.out.println("String可以用于switch语句");    

 break;    

 }    //报错！！！ 

5. short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?

答：对于short s1 = 1; s1 = s1 + 1; 中s1 = s1 + 1;默认是int型的。

 

如果想继续计算，必须加强制转换

 

         short s1 = 1;

 

         s1 = (short) (s1 + 1);

 

对于short s1 = 1; s1 += 1;  该段程序是没有错误的。

 

6. 说说&和&&的区别；

答：&是位运算符，表示按位与运算，&&是逻辑运算符，表示逻辑与(and)。

if(expression1 & expression2){}中expression1 和expression2 无论expression1返回true还是false，都会继续判断expression2的返回值

if(expression1 && expression2){}中如果expression1 返回false，那么expression2 不执行，跳出if语句，如果expression1 返回true，继续判断expression2

 

7. char能否表达一个中文汉字。

答：可以的。

 

Example：

 

         char cc = '说';

 

         System.out.println(cc); 

 

可以执行并输出“说”

 

 

2013-07-16

1. 静态变量和实例变量的区别？

答：在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。

 

在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

 

2. 能否从static方法内部访问非static方法？

答：不可以。

 

static修饰的方法可以直接用类名调用，非static修饰的方法必须用类new出对象才能调用。当我们用类名直接调用时，可能这个类的对象并没有new，如果这时候static方法里调用非static的方法就会出现异常。

 

3. Math.round(11.5)等於多少? Math.round(-11.5)等於多少?

答：Math.round() 函数是向上取整。

 

所以Math.round(11.5)等於 12；Math.round(-11.5)等於 - 11。

 

4. 数组长度和字符串长度如何获取。

答：数组长度的获取：数组名.length。Eg：arr.length。

 

字符串长度的获取：字符串名.length()。Eg：string.length()。

 

字符串是length() 方法，数组是length 属性。

 

5. 满足重载的条件是什么，构造方法和普通方法都可以重载吗?

答：函数重载要求方法名一致，参数列表不一样（包括参数的个数、顺序、数据结构）。

 

构造方法和普通方法都是可以重载的。

 

6. 如何把一段逗号分割的字符串转换成一个数组；

答：拆分字符串可以运行split函数。

 

Example：//将字符串str1按照逗号拆分并输出的程序如下所示

 

 

System.out.println("拆分"); 

String[] strarr = str1.split(","); 

for(String s : strarr){ 

    System.out.print(s+"\t"); 

} 

7. Integer和int的区别？什么是自动装箱、自动拆箱？

答：int 是基本数据类型，Integer是其包装类。

 

Java为每个原始类型提供了封装类，Integer是java为int提供的封装类。int的默认值为0，而Integer的默认值为null，即Integer可以区分出未赋值和值为0的区别，int则无法表达出未赋值的情况，例如，要想表达出没有参加考试和考试成绩为0的区别，则只能使用Integer。

 

自动装箱：Java编译器将基本数据类型自动转换为包装类的过程。

 

例如：Integer i = 100;

 

    相当于编译器自动作以下的语法编译：Integer i = new Integer(100);

 

自动拆箱：Java编译器将包装类自动转换为基本数据类型的过程。

 

例如：

 

Integer i = 100;

 

int x = i;

 

相当于编译器自动作以下的语法编译：int x = i.intValue();

 

 

2013-07-17

1.  "=="和equals方法究竟有什么区别？

答：==和equals的区别

 

1. ==可以用来比较基本类型和引用类型，判断内容和内存地址

 

2. equals只能用来比较引用类型,它只判断内容。该函数存在于老祖宗类 java.lang.Object

 

对于复合数据类型之间进行equals比较，在没有覆写equals方法的情况下，他们之间的比较还是基于他们在内存中的存放位置的地址值的，因为Object的equals方法也是用双等号（==）进行比较的，所以比较后的结果跟双等号（==）的结果相同。

 

2. Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?

答：Overload表示方法重载，针对的是单一类。Overload要求方法名一样，而参数列表要不一样（包括参数的个数、顺序、数据类型）。

 

Override表示方法覆盖，针对的是有继承关系的类。当子类的某一方法与父类的方法名一样，并且参数列表完全一样（包括参数的个数、顺序、数据类型）的时候，我们称之为方法覆盖。

 

3. 接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承具体类(concrete class)? 抽象类中是否可以有静态的main方法？

答：接口可以继承接口。并且，接口之间的继承也允许多重继承的情况。

 

Example1：

 

interface A {}

 

interface AA {}

 

interface AAA extends A,AA{}

 

抽象类也可以实现接口。

 

Example2：

 

interface A {}

 

interface AA {}

 

interface AAA extends A,AA{}

 

abstract class D implements AAA {}

 

抽象类可以继承具体类。

 

Example3：

 

class E{}

 

abstract class F extends E{}

 

抽象类中可以有静态的main方法：

 

Example4：

 

abstract class TestDemo_InterfaceTest{

 

public static void main(String[] args) {

 

System.out.println("Hello World!");

 

}

 

}

 

4. abstract class和interface有什么区别?

答：声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。

 

接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。

 

 

2013-07-18

1. 简述OOP三大特征。

答：①、封装

    所谓封装，就是将某些东西包装和隐藏起来，让外界无法直接使用，只能通过某些特定的方式才能访问。OOP将万物都视为“对象”，任何对象都具有特性和行为。我们将其特性称为“成员变量”，将其行为称之为“成员函数”，被封装的特性只能通过特定的行为去访问。

 

②、继承

   后代具有祖先的某些特点就叫继承，当然后代还可以具有自己独有的特征。继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。

 

③、多态

 

多态性是允许将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。即通过多态，相同类型的变量，调用相同的方法，却能够产生不同的结果。

 

2. Java中实现多态的机制是什么?什么是造型，为什么要造型？

答：Java中实现多态的机制靠的是父类或者接口定义的引用变量可以指向子类或者具体的实现类的实例对象，而程序调的方法在运行期才动态绑定，就是引用变量所指向的具体实例对象的方法，也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。

 

具体来说，就是父类A有一个方法function()，子类B,C分别继承A并且重写function()，当创建一个对象A b = new B(); b.function()就调用B的funciotn,假如你new C(),那调用的就是C重写的function。怎么判断使用那个类的function就是动态绑定，这个现象就是多态。

 

造型是将父类类型引用变量的值直接赋给声明为子类类型的变量。

 

造型的作用：在多态中，由于对象以其父类的身份出现，所以对子类中新添加的成员的访问受到限制，若想实现这些受限制的方法，就需要通过造型来恢复一个对象的本来面目。

 

 

2013-07-19

1. 如何把一段逗号分割的字符串转换成一个数组?

答：拆分字符串可以运行split函数。

 

Example：//将字符串str1按照逗号拆分并输出的程序如下所示

 

 

System.out.println("拆分"); 

String[] strarr = str1.split(","); 

for(String s : strarr){ 

System.out.print(s+"\t"); 

} 

2. 运行时异常和声明型异常有什么区别？举出常见的几个RuntimeException

异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。

 

java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。

 

3. String和StringBuffer、StringBuilder的区别。

String类提供了数值不可改变的字符串。

 

StringBuffer类提供的字符串进行修改。并且它是线程安全的。

 

StringBuilder 和StringBuffer类一样，只是他的字符串变量是非线程安全的。

 

4. String s = "Hello";s = s + " world!";这两行代码执行后，原始的String对象中的内容到底变了没有？

答：没有。因为String是不可变类，所以它的所有对象都是不可变对象。执行代码后，s不指向原来那个对象了，而指向了另一个 String对象，内容为"Hello world!"，原来那个对象还存在于内存之中，只是s这个引用变量不再指向它了。

 

5. 什么是内部类？Static Nested Class 和 Inner Class的不同。

答：内部类可以说是外部类的一个普通成员。

 

静态的Static nested class是不可以直接调用它的外部类enclosing class的，但是可以通过外部类的引用来调用，就像你在一个类中写了main方法一样。

 

非静态类inner class 可以自由的引用外部类的属性和方法，但是它与一个实例绑定在了一起，不可以定义静态的属性、方法 。

 

Inner Class（内部类）定义在类中的类。

 

Nested Class（嵌套类）是静态（static）内部类。1. 要创建嵌套类的对象，并不需要其外围类的对象。 2. 不能从嵌套类的对象中访问非静态的外围类对象。

 

 

2013-07-20

1. 介绍Collection框架的结构. Collection和Collections的区别？

答：Collection框架的完整结构

 

1.类集框架最大的接口：Collection、Map、Iterator、Enumeration

 

2.Collection：存放单值

 

   |- List：允许有重复内容，有序

 

       |- ArrayList：异步处理，新的操作类，非线程安全。

 

       |- Vector：同步处理，旧的操作类，线程安全。支持Enumeration输出

 

   |- Set：不允许有重复内容，无序，靠hashCoke()和equals()进行重复的严重

 

       |- HashSet：无序存放

 

       |- TreeSet：有序存放，安Comparable排序

 

3.Map：存放一对值

 

   |- HashMap：新的类，异步处理，非线程安全，允许有null

 

   |- Hashtable：旧的类，同步处理，线程安全，不允许有null

 

        |- Properties：属性操作类

 

   |- TreeMap：有序排列，按key排序，根据Comparable指定排序规则

 

4.Iterator:

 

   |- 迭代输出，依靠Collection接口中的iterator方法输出，是新的输出标准

 

5.Enumeration：旧的输出标准

 

  Collection和Collections的区别：

 

Collection是集合类的上级接口，继承与他的接口主要有Set 和List.

Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

 

2. List、Set和Map的区别，Map是否是Collection子接口？说出它的主要方法，及各种类型的存储性能区别。

答：List、Set和Map的区别：

 

List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。 和Set不同，List允许有相同的元素。

 

Set是一种不包含重复的元素的Collection，即任意的两个元素e1和e2都有e1.equals(e2)=false，Set最多有一个null元素。 Set的构造函数有一个约束条件，传入的Collection参数不能包含重复的元素。

 

Map提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个value。Map接口提供3种集合的视图，Map的内容可以被当作一组key集合，一组value集合，或者一组key-value映射。

 

Map不是Collection的子接口。

 

实现List接口的常用类有LinkedList，ArrayList，Vector和Stack。

LinkedList类：

LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法在LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。 LinkedList没有同步方法。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：

List list = Collections.synchronizedList(new LinkedList(...));

ArrayList类：

ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。

size，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为线性。每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。和LinkedList一样，ArrayList也是非同步的（unsynchronized）。

Vector类：

Vector非常类似ArrayList，但是Vector是同步的。由Vector创建的Iterator，虽然和ArrayList创建的Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出ConcurrentModificationException，因此必须捕获该异常。

Stack 类：

Stack继承自Vector，实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop方法，还有peek方法得到栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。

 

实现Set接口的常用类有HashSet，TreeSet。

 

HashSet是Set接口的一个子类，主要的特点是：里面不能存放重复元素，而且采用散列的存储方式，所以没有顺序。

 

TreeSet的主要特点是：可对输入的数据进行有序排列。

 

实现Map接口的常用类有Hashtable，HashMap，Treemap。

 

Hashtable类：

 

Hashtable继承Map接口，实现一个key-value映射的哈希表。任何非空（non-null）的对象都可作为key或者value。 添加数据使用put(key, value)，取出数据使用get(key)，这两个基本操作的时间开销为常数。 Hashtable通过initial capacity和load factor两个参数调整性能。通常缺省的load factor 0.75较好地实现了时间和空间的均衡。增大load factor可以节省空间但相应的查找时间将增大，这会影响像get和put这样的操作。 Hashtable是同步的。

HashMap类：

HashMap和Hashtable类似，不同之处在于HashMap是非同步的，并且允许null，即null value和null key。，但是将HashMap视为Collection时（values()方法可返回Collection），其迭代子操作时间开销和HashMap的容量成比例。因此，如果迭代操作的性能相当重要的话，不要将HashMap的初始化容量设得过高，或者load factor过低。

WeakHashMap类：

Treemap：适用于按自然顺序或自定义顺序遍历键(key)。

1. AWT和Swing的区别，如何设置look and feel？如何往JFrame添加组件。

答：AWT 是抽象窗口组件工具包，是 java 最早的用于编写图形节目应用程序的开发包。

Swing 是为了解决 AWT 存在的问题而新开发的包，它以 AWT 为基础的。

 

设置look and feel：

 

try{

    UIManager.setLookAndFeel(外观名称);

   }catch(Exception e){}

 

方法setLookAndFeel的一些参数:

 

UIManager.getCrossPlatformLookAndFeelClassName()

 

--Java的界面外观, 所有平台均一致.

 

UIManager.getSystemLookAndFeelClassName()

 

--指定为当前平台的界面外观.在32位Windows平台, 为Windows界面外观; 在Mac OS平台, 为Mac OS界面外观; 在Sun平台, 为CDE/Motif界面外观.

 

"javax.swing.plaf.metal.MetalLookAndFeel"

 

--指定为Java的界面外观, 也就是方法UIManager.getCrossPlatformLookAndFeelClassName()的返回值.

 

"com.sun.java.swing.plaf.windows.WindowsLookAndFeel"

 

--指定为Windows的界面外观, 仅在Windows平台起作用.

 

"com.sun.java.swing.plaf.motif.MotifLookAndFeel"

 

--指定为CDE/Motif的界面外观, 可以在所有平台起作用.

 

"javax.swing.plaf.mac.MacLookAndFeel"

 

--指定为Mac OS的界面外观, 仅在Mac OS平台起作用。

 

 Swing 程序用JFrame 对象实现了它们的窗口。JFrame 类是AWT Frame 类的一个子类。它还加入了一些Swing 所独有的特性。与 Frame 的使用十分相似。唯一的区别在于，不能将组件加入到JFrame中。可以或者将组件加入到JFrame 的content pane(内容面板) 中，或者提供一个新的content pane(内容面板)。

 

对JFrame添加组件有两种方式：

　　1)用 getContentPane ()方法获得JFrame的内容面板，再对其加入组件：frame. getContentPane ().add(childComponent)

　　2)建立一个Jpanel或JDesktopPane之类的中间容器，把组件添加到容器中，用setContentPane()方法把该容器置为JFrame的内容面板：

　　　　JPanel contentPane = new JPanel();

　　　　……//把其它组件添加到Jpanel中;

　　　　frame.setContentPane(contentPane);

　　　　//把contentPane对象设置成为frame的内容面板

 

2. 说出常用的几个布局管理器和其特点。

答：常用的几个布局管理器和其特点：

 

包---类---特点

java.awt ---CardLayout--- 将组件象卡片一样放置在容器中，在某一时刻只有一个组件可见。

java.awt--- FlowLayout--- 将组件按从左到右而后从上到下的顺序依次排列，一行不能放完则折到下一行继续放置。

java.awt ---GridLayout ---形似一个无框线的表格，每个单元格中放一个组件。

java.awt ---BorderLayout ---将组件按东、南、西、北、中五个区域放置，每个方向最多只能放置一个组件。

java.awt--- GridBagLayout--- 非常灵活，可指定组件放置的具体位置及占用单元格数目。

 

3. Frame和Dialog默认的布局管理器是什么，Panel的又是什么？

答：Frame默认的布局管理器是：BorderLayout

 

Dialog默认的布局管理器是：BorderLayout

 

Panel默认的布局管理器是：FlowLayout

 

 

2013-07-23

IO写入和复制文件

 

//package com.app; 

 

import java.io.*; 

 

public class Test_IODemo { 

    public static void main(String[] args) { 

        ForFileWriter("用FileWriter写入文件", "以FileWriter写入.txt"); 

        ForBufferedWriter("用BufferedWriter写入文件", "以BufferedWriter写入.txt"); 

        FileCopy1("我.txt", "字符流复制.txt"); 

        FileCopy2("我.txt", "字节流复制.txt"); 

        FileCopy3("我.txt", "处理流复制.txt"); 

    } 

    //用FileWriter写入文件 

    public  static void ForFileWriter(String string,String fileName) { 

        File file = new File(fileName); 

        try { 

            FileWriter fWriter = new FileWriter(file); 

            fWriter.write(string); 

            fWriter.close(); 

        } catch (Exception e) { 

            // TODO: handle exception 

            e.printStackTrace(); 

        } 

    } 

    //用BufferedWriter写入文件 

    public static void ForBufferedWriter(String string,String desFile) { 

        BufferedWriter bWriter = null; 

        try { 

            bWriter = new BufferedWriter(new FileWriter(new File(desFile))); 

            bWriter.write(string.toString()); 

            bWriter.close(); 

        } catch (Exception e) { 

            e.printStackTrace(); 

        } 

    } 

    //字符流复制 

    public static void FileCopy1(String readfile,String writeFile) { 

        try { 

            FileReader input = new FileReader(readfile); 

            FileWriter output = new FileWriter(writeFile); 

            int read = input.read();         

            while ( read != -1 ) { 

                output.write(read);  

                read = input.read(); 

            }            

            input.close(); 

            output.close(); 

        } catch (IOException e) { 

            System.out.println(e); 

        } 

    } 

    //字节流复制 

    public static void FileCopy2(String readfile,String writeFile) { 

        try { 

            FileInputStream input = new FileInputStream(readfile); 

            FileOutputStream output = new FileOutputStream(writeFile); 

            int read = input.read();         

            while ( read != -1 ) { 

                output.write(read);  

                read = input.read(); 

            }            

            input.close(); 

            output.close(); 

        } catch (IOException e) { 

            System.out.println(e); 

        } 

    } 

    //处理流复制 

    public static void FileCopy3(String readfile,String writeFile) { 

        BufferedReader bReader = null; 

        BufferedWriter bWriter = null; 

        String line = null;  

        try { 

            bReader = new BufferedReader(new FileReader(new File(readfile))); 

            bWriter = new BufferedWriter(new FileWriter(new File(writeFile))); 

            while ((line = bReader.readLine())!=null) { 

                bWriter.write(line); 

                bWriter.newLine(); 

            } 

            bWriter.close(); 

            bReader.close(); 

        } catch (Exception e) { 

            // TODO: handle exception 

            e.printStackTrace(); 

        } 

    } 

} 

2013-07-24

1. 使用Swing和IO设计一个记事本程序。

答：java文件见Test_Notepad.java

 

http://blog.csdn.net/jueblog/article/details/9457517

 

可执行文件见notepad.exe

 

2. 什么是对象序列化和反序列化？说一下具体实现的核心代码；Serializable接口有什么作用。

答：把Java对象转换为字节序列的过程称为对象的序列化。

　　把字节序列恢复为Java对象的过程称为对象的反序列化。

　　对象的序列化主要有两种用途：

　　1） 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；

　　2） 在网络上传送对象的字节序列。

 

对象序列化：

 

 

public static void ser(Person p, String fileName){ 

    ObjectOutputStream oos = null; 

    try { 

        oos = new ObjectOutputStream(new FileOutputStream(new File(fileName))); 

        oos.writeObject(p); 

    } catch (Exception e) { 

        // TODO Auto-generated catch block 

        e.printStackTrace(); 

    } 

} 

对象的反序列化：

 

 

public static void unSer(String fileName){ 

    try { 

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File(fileName))); 

        Person p = (Person)ois.readObject(); 

        System.out.println(p.getAge() + p.getName());  

        } catch (Exception e) { 

        // TODO Auto-generated catch block 

        e.printStackTrace(); 

    } 

} 

3. 给定一个目录，输出其中的子目录或者文件名。

答：Java文件见 Text_IO_File.java

 

 

 

import java.io.*; 

 

//给定一个目录，输出其中的子目录或者文件名。 

//并按条件筛选输出含有指定字符串的文件 

 

public class Text_IO_File { 

    public static void main(String[] args) { 

        File directory = new File(""); 

        String pathString = null; 

        try{ 

            pathString = directory.getCanonicalPath();//获取标准的路径 

        }catch(Exception e){} 

        System.out.println("当前目录下的所有文件："); 

        FileTest_List(pathString); 

        System.out.println("当前目录下的所有Java文件："); 

        FileTest_List_Choice(pathString, ".java"); 

    } 

    //返回路径名下目录中的文件和目录。 

    public static void FileTest_List(String fileName) { 

        try { 

            File f=new File(fileName); 

            String[] arrStrings = f.list(); 

            for(String string : arrStrings){ 

                System.out.println(string); 

            } 

        } catch (Exception e) { 

            // TODO: handle exception 

            e.printStackTrace(); 

        } 

    } 

    //返回路径名下目录中含choice的文件名 

    public static void FileTest_List_Choice(String fileName,final String choice) { 

        try { 

            File f=new File(fileName); 

            String[] arrStrings = f.list(new FilenameFilter() { 

                @Override 

                public boolean accept(File dir, String name) { 

                    // TODO Auto-generated method stub 

                    return name.indexOf(choice) != -1; 

                } 

            }); 

            for(String string : arrStrings){ 

                System.out.println(string); 

            } 

        } catch (Exception e) { 

            // TODO: handle exception 

            e.printStackTrace(); 

        } 

    } 

} 

4. 编写一个程序，将a.txt文件中的单词与b.txt文件中的单词交替合并到c.txt文件中，a.txt文件中的单词用回车符分隔，b.txt文件中用回车或空格进行分隔。

答： Java文件见 Test_Merge.java

 

 

//package com.app; 

 

import java.io.*; 

 

public class Test_Merge { 

    public static void main(String[] args) { 

        WordMarge("Word1.txt", "Word2.txt", "WordMarge.txt"); 

    } 

    //将readfile1文件中的单词与readfile2文件中的单词交替合并到writeFile文件中 

    public static void WordMarge(String readfile1,String readfile2,String writeFile) {   

        BufferedReader bReader1 = null;   

        BufferedReader bReader2 = null;   

        BufferedWriter bWriter = null;   

        String line1 = null;    

        String line2 = null;    

        try {   

            bReader1 = new BufferedReader(new FileReader(new File(readfile1)));  

            bReader2 = new BufferedReader(new FileReader(new File(readfile2)));  

            bWriter = new BufferedWriter(new FileWriter(new File(writeFile)));   

            while ((line1 = bReader1.readLine())!=null | (line2 = bReader2.readLine())!=null) { 

                if(line1 != null) {   

                    bWriter.write(line1);   

                    bWriter.newLine();   

                }   

                if(line2 !=null) {   

                    bWriter.write(line2);   

                    bWriter.newLine();   

                } 

            } 

            bWriter.close();   

            bReader1.close();   

            bReader2.close();   

        } catch (Exception e) {   

            // TODO: handle exception   

            e.printStackTrace();   

        }   

    }   

} 

2013-07-25

线程的同步

 

//1package com.app; 

/**

 * Java线程：线程的同步

 */ 

 

import java.util.concurrent.*; 

 

public class Test0725_Thread_Syn4 { 

    public static void main(String[] args) { 

        final ExecutorService exec = Executors.newFixedThreadPool(1); 

        Callable call = new Callable() { 

            public String call() throws Exception { 

                // 开始执行耗时操作 

                int cash = 300; 

                String name = "张三"; 

                System.out.println(name + "现在有" + cash + "元存款"); 

                User u = new User(name, cash); 

                String[] arr = { "线程A", "线程B", "线程C", "线程D", "线程E", "线程F", 

                        "线程G", "线程H", "线程I", "线程J" }; 

                for (int i = 0; i < 10; i++) { 

                    MyThread th = new MyThread(arr[i], u, 

                            (int) (Math.random() * 1000 - 500)); 

                    th.start(); 

                } 

                Thread.sleep(1000 * 5); 

                return "线程执行完成."; 

            } 

        }; 

        try { 

            Future future = exec.submit(call); 

            String obj = future.get(1000 * 1, TimeUnit.MILLISECONDS); // 任务处理超时时间设为1 秒 

            System.out.println("任务成功返回:" + obj); 

        } catch (TimeoutException ex) { 

            System.out.println("\n处理超时啦...."); 

            System.exit(0); 

        } catch (Exception e) { 

            System.out.println("处理失败."); 

            e.printStackTrace(); 

        }    

        try {     

            Future future = exec.submit(call);     

            String obj = future.get(1000 * 1, TimeUnit.MILLISECONDS); //任务处理超时时间设为 1 秒     

            System.out.println("任务成功返回:" + obj);     

        } catch (TimeoutException ex) {     

            System.out.println("处理超时啦....");     

            ex.printStackTrace();     

        } catch (Exception e) {     

            System.out.println("处理失败.");     

            e.printStackTrace();     

        } 

         exec.shutdown();     // 关闭线程池  

         /*     int cash2 = 100;

        String name2 = "李四";

        System.out.println(name2 + "现在有" + cash2 + "元存款");

        User u2 = new User(name, cash);

        String[] arr2 = {"线程A","线程B","线程C","线程D","线程E","线程F"};

        for (int i = 0; i < 6; i++) {

            MyThread th2 = new MyThread(name2+arr2[i], u2, (int)(Math.random()*1000-500));

            th2.start();

        }*/ 

    } 

} 

class MyThread extends Thread { 

    private User u; 

    private int x = 0; 

    MyThread(String name, User u, int x) { 

        super(name); 

        this.u = u; 

        this.x = x; 

    } 

    public void run() { 

        u.oper(x); 

    } 

} 

class User { 

    private String code; 

    private int cash; 

    private int time = 0; 

    User(String code, int cash) { 

        this.code = code; 

        this.cash = cash; 

    } 

    public String getCode() { 

        return code; 

    } 

    public void setCode(String code) { 

        this.code = code; 

    } 

    public int getCash() { 

        return cash; 

    } 

    public void setCode(int cash) { 

        this.cash = cash; 

    } 

    /**

     * 业务方法

     *            添加x万元

     */ 

    public synchronized void oper(int x) { 

        if ((this.cash +x >= 1000) && x > 0 ) { 

            System.out.println(Thread.currentThread().getName() + "暂停！"+"当前账户余额为：" + this.cash + "，您还想存" +x + "，太多了！"); 

            try { 

                Thread.yield(); 

        //      Thread.sleep(100); 

                this.wait(); 

            } catch (Exception e) { 

                // TODO Auto-generated catch block 

                e.printStackTrace(); 

            } 

             

        }else if (this.cash + x <0) { 

            System.out.println(Thread.currentThread().getName() + "暂停！"+"当前账户余额为：" + this.cash + "，小于所取额 " +x +"，余额不足！"); 

            try { 

                Thread.yield(); 

        //      Thread.sleep(100); 

                this.wait(); 

            } catch (Exception e) { 

                // TODO Auto-generated catch block 

                e.printStackTrace(); 

            } 

        } 

         if(this.cash < 1000 && this.cash > 0 && (this.cash + x >= 0) && (this.cash + x <= 1000)){ 

                this.cash += x; 

                System.out.println(Thread.currentThread().getName() + "运行结束，增加“ " 

                        + x + " ”，当前用户账户余额为：" + this.cash); 

                time++; 

                this.notifyAll(); 

        } 

        this.notifyAll(); 

    } 

    @Override 

    public String toString() { 

        return "User{" + "code='" + code + '\'' + ", cash=" + cash + '}'; 

    } 

} 

2013-07-26

1. 同步有几种实现方法。

答：Java的同步可以用synchronized关键字来实现。

主要有两种方法：

sychronized同步代码，需要绑定一个对象，如synchronized(obj){}

sychronized同步一个方法，是对方法进行线程同步。如public void synchronized methodA(){}

 

2. 线程的基本状态(生命周期)。

答：java中，每个线程都需经历创建、就绪、运行、阻塞和终止五种状态，线程从创建到终止的状态变化称为生命周期。

 

用new运算符和Thread类或其子类建立一个线程对象后，该线程就处于创建状态。

 

创建--->就绪:通过调用start()方法

 

就绪--->运行:处于就绪状态的线程一旦得到CPU，就进入运行状态并自动调用自己的run()方法

 

运行--->阻塞:处于运行状态的线程,执行sleep()方法，或等待I/O设备资源，让出CPU并暂时中止自己运行，进入阻塞状态

 

阻塞--->就绪:睡眠时间已到,或等待的I/O设备空闲下来，线程便进入就绪状态，重新到就绪队列中等待CPU。当再次获得CPU时，便从原来中止位置开始继续运行。

 

运行--->终止：(1)(正常情况下)线程任务完成

                 (2)(非正常状况)线程被强制性的中止,如通过执行stop()或destroy()方法来终止一个线程

 

3. 简述synchronized和java.util.concurrent.locks.Lock的异同。

答：主要相同点：

 

　　Lock能完成synchronized所实现的所有功能。

 

主要不同点：

 

1）Lock有比synchronized更精确的线程语义和更好的性能。

 

2）synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。

 

4. 设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。写出程序。

答：Java代码见ThreadTest.java

 

 

//package com.app; 

 

 

public class ThreadTest { 

    static int t = 10; 

    static final int TIME = 5; 

    public static void main(String[] args) { 

        ThreadTest test = new ThreadTest(); 

         

        AddTest thread1 = test.new AddTest(); 

        MinusTest thread2 = test.new MinusTest(); 

        for (int i = 0; i < 2; i++) { 

            new Thread(thread1).start(); 

            new Thread(thread2).start(); 

        } 

    } 

     

    private synchronized void Add() { 

        t++; 

        System.out.println(Thread.currentThread().getName() + "--加法--" +t); 

    } 

    class AddTest implements Runnable{ 

        @Override 

        public void run() { 

            // TODO Auto-generated method stub 

            for (int i = 0; i < TIME; i++) { 

                Add(); 

            } 

        } 

    } 

     

    private synchronized void Minus() { 

        t--; 

        System.out.println(Thread.currentThread().getName() + "--减法--" +t); 

    } 

    class MinusTest implements Runnable{ 

        @Override 

        public void run() { 

            // TODO Auto-generated method stub 

            for (int i = 0; i < TIME; i++) { 

                Minus(); 

            } 

        } 

    } 

} 

1. Socket是什么？如何开发基于C/S结构下的Socket程序，请说出步骤。

答：SOCKET用于在两个基于TCP/IP协议的应用程序之间相互通信。最早出现在UNIX系统中，是UNIX系统主要的信息传递方式。在WINDOWS系统中，SOCKET称为WINSOCK。

两个基本概念：客户方和服务方。当两个应用之间需要采用SOCKET通信时，首先需要在两个应用之间（可能位于同一台机器，也可能位于不同的机器）建立SOCKET连接，发起呼叫连接请求的一方为客户方，接受呼叫连接请求的一方成为服务方。客户方和服务方是相对的，同一个应用可以是客户方，也可以是服务方。

在客户方呼叫连接请求之前，它必须知道服务方在哪里。所以需要知道服务方所在机器的IP地址或机器名称，如果客户方和服务方事前有一个约定就好了，这个约定就是PORT（端口号）。也就是说，客户方可以通过服务方所在机器的IP地址或机器名称和端口号唯一的确定方式来呼叫服务方。在客户方呼叫之前，服务方必须处于侦听状态，侦听是否有客户要求建立连接。一旦接到连接请求，服务方可以根据情况建立或拒绝连接。连接方式有两种，同步方式（Blocking）和(noBlocking).

 

开发基于C/S结构下的Socket程序的步骤：

 

1）Server端(创建ServerSocket的实例)；Client端(创建Socket)；

 

2）打开连接到socket的输入/输出流；

 

3）按照一定的协议对socket进行读/写操作；

 

4）关闭socket。

 

2. 如何遍历集合类下的ArrayList、Vector、HashSet。如何遍历HashMap。写出核心代码。

答：遍历ArrayList：

 

 

//输出集合collection中的所有元素 

public static void Shuchu(Collection collection) { 

    Iterator iterator = collection.iterator(); 

    while (iterator.hasNext()) { 

        System.out.println(iterator.next()); 

    } 

} 

遍历ArrayList：

 

 

Vector v = new Vector(); 

for (int index = 0; index < v.size(); index++) { 

    String str = (String) v.elementAt(index); 

} 

遍历 HashSet：

 

 

Set set = new HashSet(); 

for (int i = 0; i < 100; i++) { 

    set.add("123"); 

} 

for (Iterator it = set.iterator(); it.hasNext();) { 

    System.out.println(it.next()); 

} 

遍历HashMap：

 

 

Map map = new HashMap(); 

  for(int i=0;i<100;i++) 

  { 

   map.put(i, "123"); 

  } 

for(Entry entry:map.entrySet()) 

  { 

   System.out.println(entry.getKey()+"="+entry.getValue()); 

  } 

2013-07-30

SQL的增删改查

[sql] view plaincopy

#增 

INSERT INTO t_userr(username,password,sex) values('jj','11','n'); 

#删 

DELETE FROM t_userr WHERE username = 'jj'; 

#改 

UPDATE t_userr SET ruxueYear='2000',note="水电费" WHERE username='jj'; 

#查 

SELECT id,username FROM t_userr WHERE sex='男'; 

SELECT username FROM t_userr; 

SELECT realName FROM t_userr WHERE sex='男' AND school='中国计量学院'; 

SELECT * FROM t_userr;#全部信息 

SELECT * FROM t_userr WHERE sex='女'; 

用Java向数据库中增加多条记录

 

package com.app; 

 

public class GrilFriend { 

    public static void main(String[] args) { 

        BaseDAO bDao = new BaseDAO(); 

        String[] secondclassify = {"面部护理","眼唇护理","精油SPA","彩妆","香氛","化妆工具"}; 

        String[][] thirdclassify = new String[secondclassify.length][2]; 

        String[][][] project = new String[secondclassify.length][thirdclassify.length][10]; 

        int ss = 1; 

        for (int i = 0; i < secondclassify.length; i++) { 

            for (int j = 0; j < thirdclassify[i].length; j++) { 

                thirdclassify[i][j]=(j==0)?"分类":"功效"; 

                for (int j2 = 0; j2 < 10; j2++) { 

                    project[i][j][j2] = secondclassify[i] + thirdclassify[i][j] + j2; 

                    Object[] s3 = {ss++,"化妆品",secondclassify[i],thirdclassify[i][j],project[i][j][j2]}; 

                    bDao.Update("insert into girlfriend(id,firstclassify,secondclassify,thirdclassify,project) values(?,?,?,?,?)",s3); 

                } 

            } 

        } 

    }  

} 

分类别查询最小的生日

[sql] view plaincopy

SELECT * FROM t_userr WHERE birthdate in(SELECT MAX(birthdate) FROM t_userr GROUP BY sex); 

 

2013-07-31

in和exists区别

in

 

in可以分为三类：

　　1、形如select * from t1 where f1 in （ &apos；a &apos；， &apos；b &apos；），应该和以下两种比较效率

　　select * from t1 where f1= &apos；a &apos； or f1= &apos；b &apos；

　　或者 select * from t1 where f1 = &apos；a &apos； union all select * from t1 f1= &apos；b &apos；

　　你可能指的不是这一类，这里不做讨论。

　　2、形如select * from t1 where f1 in （select f1 from t2 where t2.fx= &apos；x &apos；），

　　其中子查询的where里的条件不受外层查询的影响，这类查询一般情况下，自动优化会转成exist语句，也就是效率和exist一样。

　　3、形如select * from t1 where f1 in （select f1 from t2 where t2.fx=t1.fx），

　　其中子查询的where里的条件受外层查询的影响，这类查询的效率要看相关条件涉及的字段的索引情况和数据量多少，一般认为效率不如exists.

　　除了第一类in语句都是可以转化成exists 语句的，一般编程习惯应该是用exists而不用in.

　　A，B两个表，

　　（1）当只显示一个表的数据如A，关系条件只一个如ID时，使用IN更快：

　　select * from A where id in （select id from B）

　　（2）当只显示一个表的数据如A，关系条件不只一个如ID，col1时，使用IN就不方便了，可以使用EXISTS：

　　select * from A

　　where exists （select 1 from B where id = A.id and col1 = A.col1）

　　（3）当只显示两个表的数据时，使用IN，EXISTS都不合适，要使用连接：

　　select * from A left join B on id = A.id

　　所以使用何种方式，要根据要求来定。

exists

 

exists是用来判断是否存在的，当exists(查询)中的查询存在结果时则返回真，否则返回假。not exists则相反。

exists做为where 条件时，是先对where前的主查询询进行查询，然后用主查询的结果一个一个的代入exists的查询进行判断，如果为真则输出当前这一条主查询的结果，否则不输出。

in和exists区别

 

in 是把外表和内表作hash 连接，而exists是对外表作loop循环，每次loop循环再对内表进行查询。

一直以来认为exists比in效率高的说法是不准确的。

如果查询的两个表大小相当，那么用in和exists差别不大。

如果两个表中一个较小，一个是大表，则子查询表大的用exists，子查询表小的用in。

NOT EXISTS,exists的用法跟in不一样，一般都需要和子表进行关联，而且关联时，需要用索引，这样就可以加快速度。

 

exists 相当于存在量词：表示集合存在,也就是集合不为空只作用一个集合。

例如 exist P 表示P不空时为真; not exist P表示p为空时为真。

in表示一个标量和一元关系的关系。

例如：s in P表示当s与P中的某个值相等时 为真; s not in P 表示s与P中的每一个值都不相等时为真：

 

not in 和not exists

如果查询语句使用了not in 那么内外表都进行全表扫描，没有用到索引；

而not extsts 的子查询依然能用到表上的索引。

所以无论那个表大，用not exists都比not in要快。

 

2013-08-01

MySQL性能优化

 

2013-08-02

以Java代码实现自增长并向数据库中一次性增添多条记录

 

package com.dao; 

import java.util.*; 

public class Test_Oracle { 

    static int id = new Oracle_DAO().MaxID("SELECT MAX(id)  FROM Oracle_Test")+1; 

//  static int id = 1; 

    /** 产生一个随机的字符串，适用于JDK 1.7 */ 

//  public static String random(int length) { 

//      StringBuilder builder = new StringBuilder(length); 

//      for (int i = 0; i < length; i++) { 

//          builder.append((char) (ThreadLocalRandom.current().nextInt(33, 128))); 

//      } 

//      return builder.toString(); 

//  } 

    /** 产生一个随机的字符串*/ 

    public static String RandomString(int length) { 

        String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; 

        Random random = new Random(); 

        StringBuffer buf = new StringBuffer(); 

        for (int i = 0; i < length; i++) { 

            int num = random.nextInt(62); 

            buf.append(str.charAt(num)); 

        } 

        return buf.toString(); 

    } 

    /** 得到 id 的下标 */ 

    public static int IDNumber() { 

        return id++; 

    } 

    public static void main(String[] args) { 

        Oracle_DAO bDao = new Oracle_DAO(); 

        String sql = "insert into Oracle_Test(id,username,password) select ?,?,? from dual"; 

        String sqlString = " union select ?,?,? from dual "; 

        ArrayList