java，

java，

Java 数据结构

• 枚举（Enumeration）
• 位集合（BitSet）
• 向量（Vector）
• 栈（Stack）
• 字典（Dictionary）
• 哈希表（Hashtable）
• 属性（Properties）
• 集合框架

所有的集合框架都包含如下内容：

• 接口
  是代表集合的抽象数据类型。接口允许集合独立操纵其代表的细节。在面向对象的语言，接口通常形成一个层次。
• 实现（类）
  是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构。
• 算法
  是实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序。这些算法被称为多态，那是因为相同的方法可以在相似的接口上有着不同的实现。

Set和List的区别

• Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。
• Set检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。
• List和数组类似，可以动态增长，根据实际存储的数据的长度自动增长List的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 。

集合实现类（集合类）
集合算法
如何使用迭代器
采用迭代器遍历集合框架，它是一个对象，实现了Iterator 接口或ListIterator接口//感觉这样的话很绕口，…对象实现了接口，WTF？？

foreach(String str:strArray)
{System.out.println(str)}
foreach的语句格式：
for(元素类型t 元素变量x : 遍历对象obj){
引用了x的java语句;}

/** 
 * foreach输出二维数组测试 
 */ 
public void testArray2() { 
    int arr2[][] = {{4, 3}, {1, 2}}; 
    System.out.println("----3----foreach输出二维数组测试"); 
    for (int x[] : arr2) { 
        for (int e : x) { 
            System.out.println(e); //逐个输出数组元素的值 
        } 
    } 
} 


/** 
 * foreach输出三维数组 
 */ 
public void testArray3() { 
    int arr[][][] = { 
            {{1, 2}, {3, 4}}, 
            {{5, 6}, {7, 8}} 
    }; 

    System.out.println("----4----foreach输出三维数组测试"); 
    for (int[][] a2 : arr) { 
        for (int[] a1 : a2) { 
            for (int x : a1) { 
                System.out.println(x); 
            } 
        } 
    } 
} 

Iterator<String> ite=list.iterator();
 while(ite.hasNext())//判断下一个元素之后有值
 {
     System.out.println(ite.next());
 }

任何对象加入集合类后，自动转变为Object类型，所以在取出的时候，需要进行强制类型转换。

泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

• 所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前。
• 每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。
• 类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符。
• 泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型，不能是原始类型（像int,double,char的等）。

List < ? > ss = new List < ? > ();
?你想放啥类型就放啥类型，这就叫泛型

ArrayList < String >  array = new ArrayList < String > ();        Integer i = new Integer(123);        
array.add(i);//Error,不能将Integer类型装入容器中        
String s = "123456";        
array.add(s);//只能装入String类型

Java 序列化
1. 对象还有类型信息？
2. 检验一个类的实例是否能序列化十分简单， 只需要查看该类有没有实现 java.io.Serializable接口。

/** 
 * 输出流并创建一个.ser的文件 
 */ 
   try
  {
     FileOutputStream fileOut =
     new FileOutputStream("/tmp/employee.ser");
     ObjectOutputStream out = new ObjectOutputStream(fileOut);
     out.writeObject(e);
     out.close();
     fileOut.close();
     System.out.printf("Serialized data is saved in  /tmp/employee.ser");
  }catch(IOException i)
  {
      i.printStackTrace();
  }

 try
  {
     FileInputStream fileIn = new FileInputStream("/tmp/employee.ser");
     ObjectInputStream in = new ObjectInputStream(fileIn);
     e = (Employee) in.readObject();
     in.close();
     fileIn.close();
  }catch(IOException i)
  {
     i.printStackTrace();
     return;
  }catch(ClassNotFoundException c)
  {
     System.out.println("Employee class not found");
     c.printStackTrace();
     return;

只是知道这么一个大概的顺序

java.net 包中提供了两种常见的网络协议的支持：

• TCP：TCP 是传输控制协议的缩写，它保障了两个应用程序之间的可靠通信。通常用于互联网协议，被称 TCP / IP。
• UDP：UDP 是用户数据报协议的缩写，一个无连接的协议。提供了应用程序之间要发送的数据的数据包。
• Socket 编程：这是使用最广泛的网络概念，它已被解释地非常详细。
• URL 处理

为什么需要socket?
不懂这么个过程
ServerSocket 类的方法
public ServerSocket(int port, int backlog, InetAddress address) throws IOException//这里有4种方法

最喜欢的还是举生活中的例子

Java的网络编程的接口大多数位于 java.net 和 java.nio 这两个package里，掌握这两个package是Java程序员必备的基础技能。

用socket写一个web server

把字节流转成字符流的适配器——InputStreamReader
把这些可能反复出现的场景提取出来，用一种通用的方法去解决它。我们把这种通用的方法叫做设计模式。
打通了字节处理与字符处理之间的堑沟。这个类就叫做适配器类

public static void main(String args[]) {
    char[] cbuf = new char[256];
    System.out.println("hey, may I have your name, please? ");
    int n = 0;
        Reader r = new InputStreamReader(System.in);
    try {
        n = r.read(cbuf);//这是什么意思？
    } catch (IOException e) {
        e.printStackTrace();
    }
    System.out.println("hello, Mr. " + cbuf[0]);//0？
}

已经有了操作文件的 File，我们的目标接口是可以处理字节的 InputStream，所以我们就需要一个可以把文件操作变成流操作的 FileInputStream。

已经有了操作网络接口的 Socket，我们的目标接口是可以处理字节的 InputStream，所以我们就需要一个可以把网络操作变成流操作的 SocketInputStream。

已经有了操作字符串的String，我们的目标接口是可以处理字符的 Reader，所以我们就需要一个可以把字符串操作变成字符操作的 StringReader。//这段话并没有看懂啊

本身是一种类型，保持类型接口不变，又能对该类型的其他子类进行加强的能力，就叫装饰者

// 文件名 SendEmail.java

import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;

public class SendEmail
{
   public static void main(String [] args)
   {   
  // 收件人电子邮箱
  String to = "abcd@gmail.com";

  // 发件人电子邮箱
  String from = "web@gmail.com";

  // 指定发送邮件的主机为 localhost
  String host = "localhost";

  // 获取系统属性
  Properties properties = System.getProperties();

  // 设置邮件服务器
  properties.setProperty("mail.smtp.host", host);

  // 获取默认session对象
  Session session = Session.getDefaultInstance(properties);

  try{
     // 创建默认的 MimeMessage 对象
     MimeMessage message = new MimeMessage(session);

     // Set From: 头部头字段
     message.setFrom(new InternetAddress(from));

     // Set To: 头部头字段
     message.addRecipient(Message.RecipientType.TO,
                              new InternetAddress(to));

     // Set Subject: 头部头字段
     message.setSubject("This is the Subject Line!");

     // 设置消息体
     message.setText("This is actual message");

     // 发送消息
     Transport.send(message);
     System.out.println("Sent message successfully....");
  }catch (MessagingException mex) {
     mex.printStackTrace();
  }
 }
}

type:要被设置为 TO, CC 或者 BCC，这里 CC 代表抄送、BCC 代表秘密抄送。举例：Message.RecipientType.TO
addresses: 这是 email ID 的数组。在指定电子邮件 ID 时，你将需要使用 InternetAddress() 方法。

一个线程完整的生命周期

阻塞状态:

• 如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种：
• 等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。
• 同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。
• 其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。
  //

三种创建线程的方法：
1. 通过实现 Runnable 接口；
2. 通过继承 Thread 类本身；
3. 通过 Callable 和 Future 创建线程。

同步通信机制，书店老板会说，你稍等，”我查一下”，然后开始查啊查，等查好了（可能是5秒，也可能是一天）告诉你结果（返回结果）。而异步通信机制，书店老板直接告诉你我查一下啊，查好了打电话给你，然后直接挂电话了（不返回结果）。然后查好了，他会主动打电话给你。在这里老板通过“回电”这种方式来回调。
阻塞和非阻塞关注的是程序在等待调用结果（消息，返回值）时的状态.

阻塞调用是指调用结果返回之前，当前线程会被挂起。调用线程只有在得到结果之后才会返回。
非阻塞调用指在不能立刻得到结果之前，该调用不会阻塞当前线程。

Thread 定义了几个构造方法，下面的这个是我们经常使用的：
Thread(Runnable threadOb,String threadName);

创建一个线程的第二种方法是创建一个新的类，该类继承 Thread 类，然后创建一个该类的实例。
继承类必须重写 run() 方法，该方法是新线程的入口点。它也必须调用 start() 方法才能执行。

在多线程编程时，你需要了解以下几个概念：

• 线程同步
• 线程间通信
• 线程死锁
• 线程控制：挂起、停止和恢复

接受数据是来不急处理的，会导致阻塞。建议用专门的线程接收数据。不负责处理，放在队列里面。然后有专门的线程去处理，把接收和处理分开。这是基本原则。如果处理数据过程太慢而队列里堆积过多，就需要监测队列大小，如果过大，就启动多个线程。至于启动多少线程，可以写算法优化。记得空闲时关闭。

造轮子就是自己把这个用自己的方式重新写一遍

import java.applet.*;
import java.awt.*;

public class HelloWorldApplet extends Applet
{
   public void paint (Graphics g)
   {
  g.drawString ("Hello World", 25, 50);
   }
}

越看越感觉做程序员真的是一件非常苦逼的事情
每一个 @ 标签必须在一个新行的开始或者在一行的开始紧跟星号(*).
多个相同类型的标签应该放成一组，一个接一个的放在一起

编程不是脑力 是体力活动