1.随机数的生成
第一种：Math类的random方法返回（0,1）之间的数，例如：
System.out.println((int)(Math.random()*100)+1);第二种：Random类的next方法，例如：推荐这种方法。
System.out.println(new Random().nextInt(100));2.数组的排序
使用数组类Arrays中的sort()方法，该类在Java.util包中，使用时必须声明，例如：
int []a=new int[10]; for (int i = 0; i < 10; i++) { a[i]=new Random().nextInt(100); } Arrays.sort(a);3.区别==与equals()方法的不同和String池的概念
一个字符串对象一旦赋值，它的内容就是固定不变的。如果强行改变它的值，会产生一个新值的字符串。在Java程序执行时会维护一个Stirng池（Pool）,对于一些可以共享的字符串对象，会现先在String池中查找是否存在相同的String内容，如果有就直接返回，而不是直接创建一个对象。在Java程序中如果运算符“==”被用于比较连个引用名称时，它是用于比较两个引用名称是否引用同一个对象，不可以用“==”来比较两个字符串的字符内容是否相等。使用new生成的对象就是放在堆空间中。
4.字符串的方法
显示字符串第一次出现的位置 ，如
str.indexof("or")
变为小写： str.toLowerCase();
变为大写：
str.toUpperCase();
5.静态成员和静态方法：
静态成员可以被实例对象也可以通过类名调用，静态方法不能访问其他成员（成员变量和成员方法），只能访问静态。
静态方法不能直接处理非静态的成员，非静态成员必须只能通过对象来访问，这意味着访问非惊天成员前须创建一个对象，创建对象后，可以通过对象去访问静态和非静态成员。
6.抽象方法声明中修饰符static和abstract不能同时使用。抽象类的子类必须实现父类中的所有抽象方法或者将自己也声明为抽象的。抽象类不具备实际的功能，只能用于派生其子类，而定义为抽象方法必须在子类派生时被覆盖，所以说若一个类被定义为抽象类，则该类不能用new运算符创建具体实际对象，必须通过覆盖的方式来实现抽象类中的方法。抽象类可以有构造方法，且构造方法可以被子类的构造方法所调用，构造方法不能被声明为抽象的。由于不能用抽象类直接创建对象，因此在抽象类内定义过早方法是多余的。
7.接口：接口的数据成员必须是 public static final.方法是public abstract。
8异常：
throw：java的关键字，该关键字就是抛出异常。（主动抛出异常）
throws：一个方法在声明是可以使用throws关键字声明要产生的若干异常，并在该方法的方法体中具体给出产生异常的操作，即用相应的异常类创建对象，并使用throw关键 字抛出该异常对象。异常对象可能有应用程序本身产生，也可能有Java虚拟机产生，这取决于产生异常的类型。该异常对象中包含了异常事件类型以及发生异常时应用程序目前的状态和调用过程等必要的信息。异常抛出后，运行系统从生成异常对象的代码开始，沿方法的调用栈逐层回溯查找，知道找到包含相应异常处理的方法，并把异常对象提交给该方法为止，之歌过程称为捕获异常（catch）（由方法抛出异常）
Java的常见异常：
try{ int []a=null; a[0]=1; }catch (NullPointerException e){ System.out.println("空指针异常"); } try{ Object object=new Object(); String str=(String)object; }catch (ClassCastException e){ System.out.println("类强制类型转换异常"); } try { int a[]=new int[-1]; }catch (NegativeArraySizeException e){ System.out.println("数组负下标异常"); } try{ int a[]=new int[1]; a[0]=0; a[1]=1; } catch (ArrayIndexOutOfBoundsException e) { System.out.println("数组下标越界异常"); } }9.多异常处理：
多异常处理是通过在一个是通过在一个try块后面定义若干个catch块来实现的，一般来说，处理较常见的catch块应放在前面，而可以与多种异常类型相匹配的catch块应放在较后位置。若将子类异常的catch语句块放在父类异常catch语句块的后面，则编译醋能通过。
10.runtimeException和非运行时异常，
非运行时异常：经常是在程序运行过程中由环境原因造成的异常，如输入输出异常，网络地址不能打开，文件未能找到等，这类异常必须在程序中使用try-catch-final语句去捕获它并进行相应的处理，否则编译就不能通过，是由Java编译器要求的。
11.输入输入
FileInputStream类：直接继承InputStream类，通过这个类可以打开本地机器文件，进行顺序读操作，FileInputStream类的对象表示一个文件字节输入流，从中可读出一个字节或一批字节，在生成FileInputStream类的对象时，如果找不到指定的文件，则会抛出FileNotFoundException异常，该异常必须捕获或生明抛出。
FileOutputStream：在生成FileOutputstream类对象时，如果找不到指定的文件，则创建一个新文件，如果文件已存在，则清除源文件的内容。
FileInputStream fin=new FileInputStream("a.txt"); FileOutputStream fout=new FileOutputStream("b.txt"); do{ i=fin.read(); if(i!=-1){ fout.write(i); } }while(i!=-1); fin.close(); fout.close();FileReader类继承自InputStreamReader类，用于字符文件的读操作，每次读取一个字符或一个字符数组，在使用FileReader类读取文件时，必须先调用FileReader()构造方法创建一个对象，再利用它来调用read()方法，读取文件中的数据。
char[]c=new char[500]; FileReader fileReader=new FileReader("a.txt"); int num=fileReader.read(c); String str=new String(c,0,num); System.out.println(str);
FileWriter类：
FileWriter继承OutputStreamWriter类，用于字符文件的写操作，每次写入一个字符，一个字符数组或一个字符串，要使用FileWriter类将数据写入文件，必须先调用FileWriter()构造方法创建FileWriter类对象，再利用它来调用write()方法将数据写入文件。
String string="好好学习，天天向上\n"; String string2="学习是一种信仰"; FileWriter fileWriter=new FileWriter("test.txt"); fileWriter.write(string); fileWriter.write(string2); fileWriter.close(); System.out.println("已经写入该文件");12.文件的操作：
（1）使用 new File("fileName").createNewFile();来创建文件。
（2）利用BufferedWriter类来向文件写入数据：
BufferedWriter bufferedWriter=new BufferedWriter(new FileWriter("a.txt")); bufferedWriter.write("桂林理工高中"); bufferedWriter.newLine(); bufferedWriter.write("Java程序设计"); bufferedWriter.newLine(); bufferedWriter.write("好好学习"); bufferedWriter.flush(); bufferedWriter.close();（3）使用BufferReader类从文件中读取数据显示在屏幕上。
String string; BufferedReader in=new BufferedReader(new FileReader("a.txt")); while((string=in.readLine())!=null){ System.out.println(string); } in.close();
(4)获取文件的属性：
File file=new File("fileName"): file.exit()：文件是否存在
getParent()显示文件的父目录，
canRead()：是否可读
canWrite():是否可写
isFile()
isDrectory()
（5）查看当前文件夹下的文件： String[]dir=new java.io.File(".").list();
String dir[]=new java.io.File(".").list(); Arrays.sort(dir); for(String s:dir){ System.out.println(s); } //查看系统驱动器列表 File []dirves= File.listRoots(); for (int i = 0; i < dirves.length; i++) { System.out.println(dirves[i]); }13.读写基本类型数据： DataInputStream类：数据输入流：实现不同数据的输入readInt(),readDouble().定义：new DataInputStream(new FileInputStream(“fileName”)）；
DataOutputStream类：数据输出流：writeInt().
从这两个构造方法中可以看出，作为过滤流，输入和输出流分别作为数据输入流和数据输出流的构造方法的参数，即作为过滤流必须与相应的数据流相连。
14.对象的写入与读取： ObjectInputStream类：
ObjectOutputStream类：
Serializable接口的实现：
package com.company; import java.io.*; import java.util.Arrays; class Student implements Serializable{ String name; int age; String dept; public Student(String name, int age, String dept) { this.name = name; this.age = age; this.dept = dept; } public String toString(){ return name+" "+age+" "+dept; } } public class Main { public static void main(String[] args) throws IOException { Student s1=new Student("liang",20,"软件工程"); Student s2=new Student("huang",25,"软件工程"); FileOutputStream fout; ObjectOutputStream dout; FileInputStream fin; ObjectInputStream din; File f=new File("test2.txt"); try{ f.createNewFile(); } catch (IOException e) { e.printStackTrace(); } try{ fout=new FileOutputStream(f); dout=new ObjectOutputStream(fout); dout.writeObject(s1); dout.writeObject(s2); dout.close(); } catch (IOException e) { e.printStackTrace(); } try{ fin=new FileInputStream(f); din=new ObjectInputStream(fin); Student r1=(Student)din.readObject(); Student r2=(Student)din.readObject(); System.out.println(r1.toString()); System.out.println(r2.toString()); din.close(); } catch (ClassNotFoundException e) { e.printStackTrace(); } } }类ObjectOutputStream的构造方法需要引入FileOutputStream对象作为参数来为用户希望存储自己对象到其中的文件定义里， 15.对对象的随机访问：
RoandomAccessFile流类能够在文件的任何位置查找或者写入数据，打开一个随机存取文件，要么进行只读操作，要么进行对鞋操作，可以通过构造方法的第二个参数来指定，r表示读取，rw表示读写：
如
RandomAccessFile inFile=new RandomAccessFile("FileName:","r");
当打开一个现有文件作为RandomAccessFile对象时，原来的文件不会被删除。随机存取文件提供了一个文件指针，文件指针总是指向下一条要进行读写操作记录的位置，seek()方法可以将文件指针设定在文件内部的任一字节文职，它的参数是一个在0到文件长度之间的long型整数。
想要从一个随机存取文件中读写数据，可以通过RandomAccesssFile类中read()和write()方法，完成文件的操作。
16.创建线程的两种方式
一种是继承java.lang包中的Thread类，另一种是用户在定义自己的类中实现Runnable接口。但不管采用哪种方法，都要用到java类库中的Thread类以及相关的方法，要在一个Thread的子类中激活线程，
铁路售票系统：
package com.company; import java.io.*; import java.util.Arrays; class SaleTicket implements Runnable{ private int tickets=1; @Override public void run() { while(true){ if(tickets<=100){ System.out.println(Thread.currentThread().getName()+"销售第"+tickets+++"票"); }else{ break; } } } } public class Main { public static void main(String[] args) throws IOException { SaleTicket t=new SaleTicket(); for (int i = 0; i < 4; i++) { new Thread(t).start(); } } }要实现这个铁路售票系统要创建同一个资源对象，但是要创建多个线程去处理同一个资源对象，实现Runnalbe接口可以避免由于Java单一继承带来的局限，并且社和多个相同程序代码的线程去处理统一资源的清况。
17.守护线程： 守护线程是一类特殊的线程，它是为其他线程的运行提供服务的后台线程，如JVM的垃圾回收、内存管理等线程都属于守护线程，守护线程并不是应用程序的核心部分，当一个应用程序的所有非守护线程终止运行时，即使任然有守护贤臣运行，应用程序也将终止，反之，只要有一个非守护线程运行，应用程序就不会终止。
将一个用户线程设置为守护线程是通过该线程对象的setDaemon(true)方法进行的，但必须是在调用start()方法启动线程之前进行设置，否则就会抛出IllegalThreadStarteException异常。如果线程是守护线程，则isDaemon()方法返回true。
18.线程同步机制： 线程同步的基本思想是避免多个线程对同一个资源的同时访问，对于这样的同步资源，Java语言使用synchronized关键字来标识，这里的资源可以是同一种类型的数据，也就是对象，也可以是一个方法，还可以是一段代码。凡是前面加有关键字synchronized的方法或代码段，系统运行时都为之分配一个互斥锁，这样就可保证在同一时间，只有衣蛾线程在享有者一资源，而不会有其他的线程在同一时间一起执行。
Java语言的Object类中提供了wait()和notify()两个方法，这两个方法只能在同步方法中被调用，执行wait()方法将使得当前正在运行的线程暂时被挂起，从执行状态转换为阻塞状态，同时该线程功能放弃占用的资源互斥锁。当有多个线程等待访问某同步资源时，他们会在该资源的互斥锁队列中排队等候，wait()方法被调用后，其他线程就会有机会获得资源，而被wait()挂起的线程将会在互斥锁队里中排队等候notify()方法唤醒它。
如消费者和生产者：
package com.company; import java.io.*; import java.util.Arrays; class Commom{ private char ch; private boolean control=false; synchronized char get(){ while(control==false){//当control的值为false时一直挂起线程 try{ wait(); } catch (InterruptedException e) { e.printStackTrace(); } } control=false; notify(); return ch; } synchronized void put(char newch){ while(control==true){//当contorl变量的值是true时，一直挂起线程 try{ wait(); } catch (InterruptedException e) { e.printStackTrace(); } } ch=newch; control=true; notify();//唤醒消费者进程 } } class Product extends Thread{ private Commom commom; public Product(Commom thiscomm){ commom=thiscomm; } public void run(){ char c; for(c='a';c<='e';c++){ System.out.println("生产的数据是："+c); commom.put(c); } } } class Comsumer extends Thread{ private Commom commom; public Comsumer(Commom thiscomm){ commom=thiscomm; } public void run(){ char c; for(int i=0;i<5;i++){ c=commom.get(); System.out.println("消费的数据是："+c); } } } public class Main { public static void main(String[] args) throws IOException { Commom commom=new Commom(); Product p=new Product(commom); Comsumer c=new Comsumer(commom); p.start(); c.start(); } }18.泛型类实质就是将数据的类型参数化，通过为类、接口及方法设置类型参数来定义泛型。泛型使一个类或一个方法可以在多种不同类型的对象上进行操作，运用泛型意味着编写的代码可以被很多类型不同的对象所重用，从而减少数据类型转换的潜在错误。容器类是Java以类库的形式供用户开发程序时可直接使用各种数据结构，一种数据结构被认为是一个容器。除数组外Java还以为是一个容器。除数组外Java还以类库的形式提供了许多其他数据结构。这些数据结构通常称为容器类或集合类。
泛型类：
集合类：编写一个程序将两个集合合并在一起。
public class Main { public static void main(String[] args) throws IOException { int[] a={2,5,9,13}; int[] b={1,3,6,9,15,21}; HashSet<Integer>setA=new HashSet<Integer>(); HashSet<Integer>setB=new HashSet<Integer>(); for (int i = 0; i < a.length; i++) { setA.add(a[i]); } for (int i = 0; i < b.length; i++) { setB.add(b[i]); } setA.addAll(setB); Iterator iterator=setA.iterator(); while(iterator.hasNext()){ System.out.println(iterator.next()); } }set《T》是一个不含重负元素的集合接口，当将两个集合对象中的元素合并在一起时，重复的元素只能保留一个。set<t>对象的数据也可以调用iterator()方法返回一个迭代器，使用迭代器遍历集合中的元素。
treemap是有序的，hashmap是无序的。
19.java语言提供了注解、反射和lambda表达式等许多特性供程序员使用。注解是代码里的特殊标记，用来告知编译器要做什么，
根据注解的作用可以将注解分为基本注解、元注解（或称元数据注解）与自定义注解三种；
反射允许程序在运行状态时，可以对任意一个字节码（.class文件）获取它的所有属性和方法，这种动态获取程序信息以及动态调用对象的功能就是Java语言的反射机制。
内部类（inner class）是定义在类中的类，而匿名内部类是一种特殊的内部类，它没有类名，在定义类或实现接口的同时，就生成该类的一个对象；函数式接口是只包含一个抽象方法的接口，
lambda表达式就是一种匿名的方法，它可以被看作是使用精简语法的匿名内部类。Java中任何Lambda表达式必定有对应的函数式接口。
利用反射获取程序元素相应的信息；
20.Java的网络编程： Java的网络编程分为3个层次。最高一级的网络通信就是从网络上下载的applet程序，客户端浏览器通过HTML文件的《applet》标记来识别applet,并解析applet的属性，通过网络获取applet的字节码文件；次一级的通行是通过URL类的对象指明文件所在位置，并在网络上下载音、视频文件和图像文件，然后对音频、视频播放和显示图像；最低一级的通行是利用java.net包中提供的类直接在程序中实现网络通信。
URL
<传输协议》：//《主机名》：端口号/<文件名》#《引用》
在创建URL对象时，若发生错误，系统会产生malformedURLExcption异常，这是非运行时异常，必须在程序中捕获处理。
URL url=new URL(urlname); System.out.println("协议名："+url.getProtocol()); System.out.println("主机名："+url.getHost()); System.out.println("端口号："+url.getPort()); System.out.println("文件名："+url.getFile()); InputStreamReader in=new InputStreamReader(url.openStream()); BufferedReader br=new BufferedReader(in); String line; while((line=br.readLine())!=null){ System.out.println(line); } }InetAddress程序设计：
Java.util包中的InetAddress类的对象包含一个Internet主机地址的域名和IP地址，
21.InputStream,OutputStream、Reader和Writer四个类在功能有何异同？
InputStream和OutputStream类是Java语言里用来处理以为（bit）为主的字节流，它除了可用来处理二进制文件数据之外，也可以用来处理文本文件;Reader和Write类则用来处理字符流的，也就是文本文件。
22.顺序录和管道流的区别是什么？
顺序输入流SequenceInputStream是InputStream的直接子类，其功能是将多个输入流顺序连接在一起，形成单一的输入数据流，没有对应的输入数据流存在；管道流用来将一个程序或线程的输出连接到另一个程序或线程作为输入，使得相连线程能够通过PipedInputStream和PipedOutputStream流进行数据交换，从而可以实现程序内部线程的通行或不同程序的通信。
23.Java语言中定义的三个标准输入输出流是什么？它们对应的什么设备?
Java语言中定义的三个标准输入输出流分别是System.in、system.out和system.err。其中，system.in对应于输入流，通常指键盘输入设备；system.out对应于输出流，指显示器、打印机或磁盘文件等信息输出设备；system.err对应标准错误输出设备，通常是显示器。
23.写文件
File f=new File("file.txt"); f.createNewFile(); //FileWriter用来写入文本文件 FileWriter fw=new FileWriter(f); String str="文件已经被成功创建!"; fw.write(str); fw.close(); char a[]=new char[100]; FileWriter fw1=new FileWriter(f,true); fw1.write("\r\n又添加异性文字"); fw1.close(); //FileReader用来读取文本文件 FileReader fr=new FileReader(f); int num=fr.read(a); String s=new String(a,0,num); System.out.println(s);
