#小白选手—为提高编程技术+期末考试，若有错误，望指正。
目录
一、容器类
1.1泛型
泛型又称为参数化类型，通过定义含有一个或多个类型参数的类或接口，对具有相似特征与行为的类进行抽象，从而提高代码的重用性。
类、接口、方法都具有泛型的特性，分别对应有泛型类、泛型接口和泛型方法。
（包装类见笔记一）
1.2容器的概念与相互关系
1.2.1概念
容器：可以存放数据的实例都可称为容器，Java容器类的对象实例就是一个容器。
1.2.1容器分类
根据所存储元素的形式，按照接口不同分类
(1)Collection:由一系列元素组成的序列，其元素是指向其它对象的引用。包括List、Set、Queue三种
List须按照元素被插入时的顺序保存元素；
Set中的元素不能重复；
Queue须按照排队规则来确定元素顺序。
(2)Map：一个由一系列“键值对”组成的序列，允许通过键查找值。Map使我们可以由一个对象查找另一个对象。Map中不能包含重复的键，且每个键最多映射到一个值。
1.2.3相互关系
注：每种接口都有二三种典型的容器实现。大致了解各容器类的继承关系。 注意Map并非继承自Collection。
1.3 List接口及其实现
与数组类似，List可以建立数字索引与具体对象的关联，区别在于List可以自动扩充容量。 Java提供了两种List容器的实现类：ArrayList和LinkedList.
ArrayList实列：（部分代码）
package exp8_ArrayList;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
public class ArrayListDemo {
static boolean checkGraduate(Student st) { //毕业资格审查
boolean b1=false,b2=false; //b1、b2用于标记两个毕业条件的检查结果
b1 = st.checkSingleFail(); //检查是否有单科不及格
if(st.aveScore()>=70) //检查平均分是否高于70
b2 = true;
else
b2 = false;
return b1&b2; //两个条件同时满足方能毕业
}
public static void main(String[] args) throws IOException{
//注意下面的写法，考点
ArrayList<Student> a = new ArrayList<>();//用List容器类实现信息动态添加
//添加6条以上学生成绩信息——利用a.add()
a.add(new Liberal(101, "刘备", new double[] {85,88,90,78,90}));
a.add(new Science(102, "关羽", new double[] {70,75,65,78,70,50}));
a.add(new Science(103, "张飞", new double[] {60,62,63,60,61,60}));
a.add(new Liberal(104, "赵云", new double[] {80,76,90,95,55}));
a.add(new Science(105, "曹操", new double[] {80,60,61,62,63,62}));
a.add(new Science(106, "孙权", new double[] {80,70,61,75,68,90}));
a.add(new Science(107, "吕布", new double[] {80,85,61,60,60,60}));
//打印所添加的学生信息(学号、姓名、各科成绩)以及该生是否能毕业(用checkGraduate()函数判断)
for(Student st:a) {
System.out.println(st);
if(checkGraduate(st))
System.out.println(st.getName() + "可以毕业");
else
System.out.println(st.getName() + "不能毕业");
}
//********上述循环遍历也可以用迭代器实现**********//
// Iterator<Student> it = a.iterator();
// Student st;
// while(it.hasNext()) {
// st = it.next();
// System.out.println(st);
// if(checkGraduate(st))
// System.out.println(st.getName() + "可以毕业");
// else
// System.out.println(st.getName() + "不能毕业");
// }
//将学生信息(学号、姓名、各科成绩)转换成成字符串数组
String[] s = new String[a.size()];
for(int i=0; i<a.size(); i++) {
s[i] = a.get(i).toString();
}
//将字符串数组输出到文本文件a.txt
FileWriter fout = new FileWriter("a.txt");
for(int i=0; i<s.length; i++) {
fout.write(s[i]+"\n");
}
fout.close();
}
}
1.4Set接口及其实现
Set不接受重复的元素。Java提供了三种Set容器的实现：HashSet、TreeSet和LinkedHashSet。
HashSet实例：
package exp8_HashSet;
import java.util.HashSet;
import java.util.Iterator;
public class BookInfo {
public static void main(String[] args) {
HashSet<Book> shoppingCart = new HashSet<>(); //创建HashSet对象，用来表示购物车
//向购物车中添加书籍
shoppingCart.add(new Book("《Java入门到精通》", "刘备", "机械工业出版社", 59.5));
shoppingCart.add(new Book("《零基础学会Java》", "孙权", "电子工业出版社", 69));
shoppingCart.add(new Book("《Java编程200例》", "曹操", "清华大学出版社", 75.5));
Iterator<Book> it = shoppingCart.iterator(); // 创建迭代器
System.out.println("您的购物车里的商品信息：\n书名\t\t作者\t出版社\t\t价格");
System.out.println("———————————————————————————————————————————————————————");
while (it.hasNext()) {// 判断购物车中是否有元素
System.out.println(it.next()); // 输出购物车中的商品
}
System.out.println("———————————————————————————————————————————————————————");
Iterator<Book> it2 = shoppingCart.iterator();
double sumMoney=0;
while(it2.hasNext()) {
sumMoney += it2.next().getPrice();
}
System.out.println("合计：\t\t\t\t\t" + sumMoney + "元\n\t\t\t\t\t->点我去结账"); //输出这3本书的总价钱
}
}
1.5Queue接口及其实现
Queue是一种先进先出(FIFO)的容器，程序从Queue的一端放入对象，从另一端取出对象，对象进入和被取出的顺序是相同的。 LinkedList实现了Queue接口，因此LinkedList可以用作Queue的一种实现。
public class Main {
public static void main(String[ ] args) {
Queue<Integer> q = new LinkedList<Integer>( );
int n=0;
for(int i=0; i<10; i++) {
n = (int)( Math.random( )*50 );
q.offer(n);
}
System.out.println(q);
System.out.println(q.peek( ));
System.out.println(q);
System.out.println(q.poll( ));
System.out.println(q);
}
}
1.6 Map接口及其实现
Map是一系列“键-值”之间的映射关系，是一种将对象(而非数字)与对象相关联的设计。例如，若想统计一篇论文中的各个英文单词的个数，可创建一个由String映射到Integer的Map。
1.7迭代器Iterator
Java设计了迭代器Iterator来实现对容器的遍历。 Collection接口中的iterator()方法可返回在该容器中进行迭代的迭代器。
public class Main {
public static void main(String[] args) {
ArrayList<String> a = new ArrayList<String>();
a.add("老大"); a.add("老二");
a.add("老三"); a.add("老幺");
for(String t:a) {
System.out.println(t);
}
a.add(3, "老四"); a.add(4, "老五");
System.out.println("--------------------");
Iterator<String> it = a.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}
二、多线程
2.1概念
由进程引入，进程是指多任务操作系统中一个个独立运行的程序。而线程是指程序内部的执行线路，比程序还小一个单位。即一个程序包含若干个线程。
多线程机制是指允许程序中并发执行多条指令序列，且相互独立。
2.2线程的创建
创建新线程的两种方法： （1）继承 Thread 类；（2）实现 Runnable 接口。
（1）继承Thread类：
1.从Thread类派生出子类，并在子类中重写run()方法来提供线程体。
2.通过创建子类对象来创建线程。
Thread类中的 start() 方法用于启动一个新线程；当新线程被启动后，JVM会自动调用该线程 run() 方法。
（2）实现Runnable接口：
1.定义一个类来实现Runnable接口，在类中提供run( )方法的具体实现。
2.将该类的一个实例对象(可称为任务)传递给Thread类的构造函数来创建线程对象。
两种线程创建方法的差异： 实现Runnable接口的方式使得线程类可以继承另一个类；直接继承Thread类的方式下，子类就无法再继承其它类了(Java只支持单继承)。
2.3线程的同步
2.3.1synchronized同步方法
2.3.2 synchronized同步块
2.3.3 synchronized原理
对象互斥锁 — 保证共享数据操作的完整性，用synchronized关键字。
当对象用synchronized修饰时，标明该对象在任意时刻只能由一个线程访问。
1.使用 Thread 类创建线程：
//利用继承Thread类的方式来创建线程
package exp9_ThreadCreate01;
//A队线程
class TeamA extends Thread {
public void run() {
for (int i = 1; i <= 11; i++) {
System.out.println("A队" + i + "号入场");
}
}
}
//B队线程
class TeamB extends Thread {
public void run() {
for (int i = 1; i <= 11; i++) {
System.out.println("B队" + i + "号入场");
}
}
}
public class Admission {
public static void main(String[] args) {
System.out.println("A、B两队球员开始入场……");
TeamA a = new TeamA(); //创建TeamA类对象
TeamB b = new TeamB(); //创建TeamB类对象
a.start(); //启动A队线程
b.start(); //启动B队线程
}
}
//反复执行该程序，观察结果2.实现Runnable接口创建线程：
//利用实现Runnable接口的方式来创建线程
package exp9_ThreadCreate02;
//A队线程
class TeamA implements Runnable {
public void run() {
for (int i = 1; i <= 11; i++) {
System.out.println("A队" + i + "号入场");
}
}
}
//B队线程
class TeamB implements Runnable {
public void run() {
for (int i = 1; i <= 11; i++) {
System.out.println("B队" + i + "号入场");
}
}
}
public class Admission {
public static void main(String[] args) {
System.out.println("A、B两队球员开始入场……");
Thread t1 = new Thread(new TeamA());
Thread t2 = new Thread(new TeamB());
t1.start();
t2.start();
}
}
三、网络编程基础
四、练习题
1.下列ServerSocket类的成员方法执行时可能阻塞线程的是，单选题
A.accept()
B.bind()
C.isClosed()
D.getInetAddress()
(A)注：accept()方法会阻塞线程的继续执行，直到接收到客户端的连接请求。
2.在Java中，（ ）类的对象可以使用“键-值对”的形式保存数据,单选题
A.ArrayList
B.LinkedList
C.HashSet
D.HashMap
(D)
3.下列四类容器，不是继承自Collection接口的是,单选题
A.Map
B.List
C.Set
D.Queue
(A)分为Collection和Map，Collection又分为List,Set,Queue
4.下列方法中可能在执行时不会阻塞线程的是,单选题
A.Writer类的write()方法
B.Scanner类的nextDouble()方法
C.ServerSocket类的accept()方法
D.BufferedReader类的readLine()方法
(A)
5.下面对四种典型容器类对象的存储元素特点，描述错误的是,单选题
A.LinkedList对象的元素存储有顺序，不可重复
B.ArrayList对象的元素存储有顺序，可重复
C.HashMap对象的元素存储无顺序，键不可重复，值可重复
D.HashSet对象的元素存储无顺序，不可重复
(A)参照了大佬文章。
扫一扫
1778
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
