集合
从上面的集合框架图可以看到，Java 集合框架主要包括两种类型的容器，一种是集合（Collection），存储一个元素集合，另一种是图（Map），存储键/值对映射。Collection 接口又有 3 种子类型，List、Set 和 Queue，再下面是一些抽象类，最后是具体实现类，常用的有 ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap 等等。
集合框架是一个用来代表和操纵集合的统一架构。所有的集合框架都包含如下内容：
接口：是代表集合的抽象数据类型。例如 Collection、List、Set、Map 等。之所以定义多个接口，是为了以不同的方式操作集合对象
实现（类）：是集合接口的具体实现。从本质上讲，它们是可重复使用的数据结构，例如：ArrayList、LinkedList、HashSet、HashMap。
算法：是实现集合接口的对象里的方法执行的一些有用的计算，例如：搜索和排序。这些算法被称为多态，那是因为相同的方法可以在相似的接口上有着不同的实现。
import java.util.*; public class Test { public static void main (String[] args) { List<String> list=new ArrayList <String>(); list.add("Hello" ); list.add("World" ); list.add("HAHAHAHA" ); for (String str : list) { System.out.println(str); } String[] strArray=new String [list.size()]; list.toArray(strArray); for (int i=0 ;i<strArray.length;i++) { System.out.println(strArray[i]); } Iterator<String> ite=list.iterator(); while (ite.hasNext()) { System.out.println(ite.next()); } } }
Java ArrayList Java ArrayList 方法
add() 将元素插入到指定位置的 arraylist 中 addAll() 添加集合中的所有元素到 arraylist 中 clear() 删除 arraylist 中的所有元素 clone() 复制一份 arraylist contains () 判断元素是否在 arraylistget () 通过索引值获取 arraylist 中的元素indexOf() 返回 arraylist 中元素的索引值 removeAll() 删除存在于指定集合中的 arraylist 里的所有元素 remove() 删除 arraylist 里的单个元素 size() 返回 arraylist 里元素数量 isEmpty() 判断 arraylist 是否为空 subList() 截取部分 arraylist 的元素 set() 替换 arraylist 中指定索引的元素 sort() 对 arraylist 元素进行排序 toArray() 将 arraylist 转换为数组 toString() 将 arraylist 转换为字符串 ensureCapacity() 设置指定容量大小的 arraylist lastIndexOf () 返回指定元素在 arraylist 中最后一次出现的位置retainAll() 保留 arraylist 中在指定集合中也存在的那些元素 containsAll() 查看 arraylist 是否包含指定集合中的所有元素 trimToSize() 将 arraylist 中的容量调整为数组中的元素个数 removeRange() 删除 arraylist 中指定索引之间存在的元素 replaceAll() 将给定的操作内容替换掉数组中每一个元素 removeIf() 删除所有满足特定条件的 arraylist 元素 forEach() 遍历 arraylist 中每一个元素并执行特定操作
Java LinkedList 以下情况使用 ArrayList :
频繁访问列表中的某一个元素。
你需要通过循环迭代来访问列表中的某些元素。
public boolean add (E e) 链表末尾添加元素，返回是否成功，成功为 true ，失败为 false 。public void add (int index, E element) 向指定位置插入元素。public boolean addAll (Collection c) 将一个集合的所有元素添加到链表后面，返回是否成功，成功为 true ，失败为 false 。public boolean addAll (int index, Collection c) 将一个集合的所有元素添加到链表的指定位置后面，返回是否成功，成功为 true ，失败为 false 。public void addFirst (E e) 元素添加到头部。public void addLast (E e) 元素添加到尾部。public boolean offer (E e) 向链表末尾添加元素，返回是否成功，成功为 true ，失败为 false 。public boolean offerFirst (E e) 头部插入元素，返回是否成功，成功为 true ，失败为 false 。public boolean offerLast (E e) 尾部插入元素，返回是否成功，成功为 true ，失败为 false 。public void clear () 清空链表。public E removeFirst () 删除并返回第一个元素。public E removeLast () 删除并返回最后一个元素。public boolean remove (Object o) 删除某一元素，返回是否成功，成功为 true ，失败为 false 。public E remove (int index) 删除指定位置的元素。public E poll () 删除并返回第一个元素。public E remove () 删除并返回第一个元素。public boolean contains (Object o) 判断是否含有某一元素。public E get (int index) 返回指定位置的元素。public E getFirst () 返回第一个元素。public E getLast () 返回最后一个元素。public int indexOf (Object o) 查找指定元素从前往后第一次出现的索引。public int lastIndexOf (Object o) 查找指定元素最后一次出现的索引。public E peek () 返回第一个元素。public E element () 返回第一个元素。public E peekFirst () 返回头部元素。public E peekLast () 返回尾部元素。public E set (int index, E element) 设置指定位置的元素。public Object clone () 克隆该列表。public Iterator descendingIterator () 返回倒序迭代器。public int size () 返回链表元素个数。public ListIterator listIterator (int index) 返回从指定位置开始到末尾的迭代器。public Object[] toArray() 返回一个由链表元素组成的数组。public T[] toArray(T[] a) 返回一个由链表元素转换类型而成的数组。
Java HashSet import java.util.HashSet;public class RunoobTest { public static void main (String[] args) { HashSet<String> sites = new HashSet <String>(); sites.add("Google" ); sites.add("Runoob" ); sites.add("Taobao" ); sites.add("Zhihu" ); sites.add("Runoob" ); System.out.println(sites); } }
Java HashMap import java.util.HashMap;public class RunoobTest { public static void main (String[] args) { HashMap<Integer, String> Sites = new HashMap <Integer, String>(); Sites.put(1 , "Google" ); Sites.put(2 , "Runoob" ); Sites.put(3 , "Taobao" ); Sites.put(4 , "Zhihu" ); System.out.println(Sites); } }
方法 描述
Java Iterator（迭代器） 迭代器 it 的两个基本操作是 next 、hasNext 和 remove。
import java.util.ArrayList;import java.util.Iterator;public class RunoobTest { public static void main (String[] args) { ArrayList<String> sites = new ArrayList <String>(); sites.add("Google" ); sites.add("Runoob" ); sites.add("Taobao" ); sites.add("Zhihu" ); Iterator<String> it = sites.iterator(); System.out.println(it.next()); while (it.hasNext()) { System.out.println(it.next()); } } }
Java Object 类
1 protected Object clone()
Java 泛型 public static < E > void printArray ( E[] inputArray ) { for ( E element : inputArray ){ System.out.printf( "%s " , element ); } System.out.println(); }
泛型类 public class Box <T> { private T t; public void add (T t) { this .t = t; } public T get () { return t; } public static void main (String[] args) { Box<Integer> integerBox = new Box <Integer>(); Box<String> stringBox = new Box <String>(); integerBox.add(new Integer (10 )); stringBox.add(new String ("菜鸟教程" )); System.out.printf("整型值为 :%d\n\n" , integerBox.get()); System.out.printf("字符串为 :%s\n" , stringBox.get()); } }
类型通配符 import java.util.*; public class GenericTest { public static void main (String[] args) { List<String> name = new ArrayList <String>(); List<Integer> age = new ArrayList <Integer>(); List<Number> number = new ArrayList <Number>(); name.add("icon" ); age.add(18 ); number.add(314 ); getData(name); getData(age); getData(number); } public static void getData (List<?> data) { System.out.println("data :" + data.get(0 )); } }
Java 序列化 Java 提供了一种对象序列化的机制，该机制中，一个对象可以被表示为一个字节序列，该字节序列包括该对象的数据、有关对象的类型的信息和存储在对象中数据的类型。
序列化对象 import java.io.*; public class SerializeDemo { public static void main (String [] args) { Employee e = new Employee (); e.name = "Reyan Ali" ; e.address = "Phokka Kuan, Ambehta Peer" ; e.SSN = 11122333 ; e.number = 101 ; 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(); } } }
反序列化对象 import java.io.*; public class DeserializeDemo { public static void main (String [] args) { Employee e = null ; 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 ; } System.out.println("Deserialized Employee..." ); System.out.println("Name: " + e.name); System.out.println("Address: " + e.address); System.out.println("SSN: " + e.SSN); System.out.println("Number: " + e.number); } }
Java 网络编程 网络编程是指编写运行在多个设备（计算机）的程序，这些设备都通过网络连接起来。
TCP：TCP（英语：Transmission Control Protocol，传输控制协议） 是一种面向连接的、可靠的、基于字节流的传输层通信协议，TCP 层是位于 IP层之上，应用层之下的中间层。TCP 保障了两个应用程序之间的可靠通信。通常用于互联网协议，被称 TCP / IP。
UDP：UDP （英语：User Datagram Protocol，用户数据报协议），位于 OSI 模型的传输层。一个无连接的协议。提供了应用程序之间要发送数据的数据报。由于UDP缺乏可靠性且属于无连接协议，所以应用程序通常必须容许一些丢失、错误或重复的数据包。
Socket 编程 套接字使用TCP提供了两台计算机之间的通信机制。 客户端程序创建一个套接字，并尝试连接服务器的套接字。
ServerSocket 类的方法 Socket 客户端实例 如下的 GreetingClient 是一个客户端程序，该程序通过 socket 连接到服务器并发送一个请求，然后等待一个响应。
import java.net.*;import java.io.*;public class GreetingClient { public static void main (String [] args) { String serverName = args[0 ]; int port = Integer.parseInt(args[1 ]); try { System.out.println("连接到主机：" + serverName + " ，端口号：" + port); Socket client = new Socket (serverName, port); System.out.println("远程主机地址：" + client.getRemoteSocketAddress()); OutputStream outToServer = client.getOutputStream(); DataOutputStream out = new DataOutputStream (outToServer); out.writeUTF("Hello from " + client.getLocalSocketAddress()); InputStream inFromServer = client.getInputStream(); DataInputStream in = new DataInputStream (inFromServer); System.out.println("服务器响应： " + in.readUTF()); client.close(); }catch (IOException e) { e.printStackTrace(); } } }
Socket 服务端实例 如下的GreetingServer 程序是一个服务器端应用程序，使用 Socket 来监听一个指定的端口。
import java.net.*;import java.io.*;public class GreetingServer extends Thread { private ServerSocket serverSocket; public GreetingServer (int port) throws IOException { serverSocket = new ServerSocket (port); serverSocket.setSoTimeout(10000 ); } public void run () { while (true ) { try { System.out.println("等待远程连接，端口号为：" + serverSocket.getLocalPort() + "..." ); Socket server = serverSocket.accept(); System.out.println("远程主机地址：" + server.getRemoteSocketAddress()); DataInputStream in = new DataInputStream (server.getInputStream()); System.out.println(in.readUTF()); DataOutputStream out = new DataOutputStream (server.getOutputStream()); out.writeUTF("谢谢连接我：" + server.getLocalSocketAddress() + "\nGoodbye!" ); server.close(); }catch (SocketTimeoutException s) { System.out.println("Socket timed out!" ); break ; }catch (IOException e) { e.printStackTrace(); break ; } } } public static void main (String [] args) { int port = Integer.parseInt(args[0 ]); try { Thread t = new GreetingServer (port); t.run(); }catch (IOException e) { e.printStackTrace(); } } }
服务端：
public class Server { public static void main (String[] args) { try { DatagramSocket server = new DatagramSocket (5060 ); DatagramPacket packet = new DatagramPacket (new byte [1024 ], 1024 ); server.receive(packet); System.out.println(packet.getAddress().getHostName() + "(" + packet.getPort() + "):" + new String (packet.getData())); packet.setData("Hello Client" .getBytes()); packet.setPort(5070 ); packet.setAddress(InetAddress.getLocalHost()); server.send(packet); server.close(); } catch (IOException e) { e.printStackTrace(); } } }
客户端:
public class Client { public static void main (String[] args) { try { DatagramSocket client = new DatagramSocket (5070 ); DatagramPacket packet = new DatagramPacket (new byte [1024 ],1024 ); packet.setPort(5060 ); packet.setAddress(InetAddress.getLocalHost()); packet.setData("Hello Server" .getBytes()); client.send(packet); client.receive(packet); System.out.println(packet.getAddress().getHostName() + "(" + packet.getPort() + "):" + new String (packet.getData())); client.close(); } catch (IOException e) { e.printStackTrace(); } } }
服务端和客户端是指计算机网络中的两个角色。
请求（Request）是指客户端向服务端发送的一条消息，用于请求服务端提供特定的资源或执行特定的操作。
Java 发送邮件 import javax.mail.*;import javax.mail.internet.InternetAddress;import javax.mail.internet.MimeMessage;import java.util.Properties;public class SendEmail { public static void main (String [] args) { String to = "3185087246@protonmail.com" ; String from = "3185087246@qq.com" ; String host = "smtp.qq.com" ; Properties properties = System.getProperties(); properties.setProperty("mail.smtp.host" , host); properties.put("mail.smtp.auth" , "true" ); Session session = Session.getDefaultInstance(properties,new Authenticator (){ public PasswordAuthentication getPasswordAuthentication () { return new PasswordAuthentication ("3185087246@qq.com" , "wahauxunfbaydebg" ); } }); for (int i=0 ;i<20 ;i++){ try { MimeMessage message = new MimeMessage (session); message.setFrom(new InternetAddress (from)); message.addRecipient(Message.RecipientType.TO, new InternetAddress (to)); message.setSubject("This is the Subject Line!" ); message.setText("测试" +i); Transport.send(message); System.out.println("邮件发送成功！" ); }catch (MessagingException mex) { mex.printStackTrace(); } } } }
Java 多线程编程
Java 提供了三种创建线程的方法：
通过实现 Runnable 接口；
通过继承 Thread 类本身；
通过 Callable 和 Future 创建线程。
下面是一个创建线程并开始让它执行的实例：
class RunnableDemo implements Runnable { private Thread t; private String threadName; RunnableDemo( String name) { threadName = name; System.out.println("Creating " + threadName ); } public void run () { System.out.println("Running " + threadName ); try { for (int i = 4 ; i > 0 ; i--) { System.out.println("Thread: " + threadName + ", " + i); Thread.sleep(50 ); } }catch (InterruptedException e) { System.out.println("Thread " + threadName + " interrupted." ); } System.out.println("Thread " + threadName + " exiting." ); } public void start () { System.out.println("Starting " + threadName ); if (t == null ) { t = new Thread (this , threadName); t.start (); } } } public class TestThread { public static void main (String args[]) { RunnableDemo R1 = new RunnableDemo ( "Thread-1" ); R1.start(); RunnableDemo R2 = new RunnableDemo ( "Thread-2" ); R2.start(); }
通过继承Thread来创建线程
class ThreadDemo extends Thread { private Thread t; private String threadName; ThreadDemo( String name) { threadName = name; System.out.println("Creating " + threadName ); } public void run () { System.out.println("Running " + threadName ); try { for (int i = 4 ; i > 0 ; i--) { System.out.println("Thread: " + threadName + ", " + i); Thread.sleep(50 ); } }catch (InterruptedException e) { System.out.println("Thread " + threadName + " interrupted." ); } System.out.println("Thread " + threadName + " exiting." ); } public void start () { System.out.println("Starting " + threadName ); if (t == null ) { t = new Thread (this , threadName); t.start (); } } } public class TestThread { public static void main (String args[]) { ThreadDemo T1 = new ThreadDemo ( "Thread-1" ); T1.start(); ThreadDemo T2 = new ThreadDemo ( "Thread-2" ); T2.start(); } }
Thread 方法 1 public void start () 使该线程开始执行；Java 虚拟机调用该线程的 run 方法。 2 public void run () 如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。 3 public final void setName (String name) 改变线程名称，使之与参数 name 相同。 4 public final void setPriority (int priority) 更改线程的优先级。 5 public final void setDaemon (boolean on) 将该线程标记为守护线程或用户线程。 6 public final void join (long millisec) 等待该线程终止的时间最长为 millis 毫秒。 7 public void interrupt () 中断线程。 8 public final boolean isAlive () 测试线程是否处于活动状态。
通过 Callable 和 Future 创建线程
创建 Callable 接口的实现类，并实现 call() 方法，该 call() 方法将作为线程执行体，并且有返回值。
创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。
使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。
调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。
public class CallableThreadTest implements Callable <Integer> { public static void main (String[] args) { CallableThreadTest ctt = new CallableThreadTest (); FutureTask<Integer> ft = new FutureTask <>(ctt); for (int i = 0 ;i < 100 ;i++) { System.out.println(Thread.currentThread().getName()+" 的循环变量i的值" +i); if (i==20 ) { new Thread (ft,"有返回值的线程" ).start(); } } try { System.out.println("子线程的返回值：" +ft.get()); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } } @Override public Integer call () throws Exception { int i = 0 ; for (;i<100 ;i++) { System.out.println(Thread.currentThread().getName()+" " +i); } return i; } }
创建线程的三种方式的对比
采用实现 Runnable、Callable 接口的方式创建多线程时，线程类只是实现了 Runnable 接口或 Callable 接口，还可以继承其他类。
使用继承 Thread 类的方式创建多线程时，编写简单，如果需要访问当前线程，则无需使用 Thread.currentThread() 方法，直接使用 this 即可获得当前线程。
Java 文档注释
@author 标识一个类的作者 @author description
import java.io.*; public class SquareNum { public double square (double num) { return num * num; } public double getNumber () throws IOException { InputStreamReader isr = new InputStreamReader (System.in); BufferedReader inData = new BufferedReader (isr); String str; str = inData.readLine(); return (new Double (str)).doubleValue(); } public static void main (String args[]) throws IOException { SquareNum ob = new SquareNum (); double val; System.out.println("Enter value to be squared: " ); val = ob.getNumber(); val = ob.square(val); System.out.println("Squared value is " + val); } }
微信
