【Programming Abstractions in Java课后习题3】数组、集合
课后习题2
课后习题1
教材是Programming Abstractions in Java， Eric.S.Roberts——Java程序设计 基础、编程抽象与算法策略。
你的三连就是我创作的最大动力！
目录
- 两节笔记
-
- 数组
- ArrayList类
- 包装器类
- 栈抽象
- 队列抽象
- 映射表抽象
- 迭代器
- 部分习题选讲
-
- ArrayList反序
- RPN计算器（栈）
- 计算词频（Map）
- 总结
两节笔记
数组
1.数组声明
type[] name=new type[size];
常量声明
public static final int N=5;
int a=new int[5];
2.Java数组索引从0开始，有一个length域，包含了元素的数量。
3.在机器语言级别上，用来表示内存内容的地址叫指针，而java中，用于传统的术语叫引用。并且，在参数传递过程复制的是对数组的引用。
4.信息基础单元（状态，例如0，1）叫位（bit），最小的组合单元称为字节，有8位构成，足以存储一个char。
5.十进制常量写为标准形式的，八进制常量前有引导0，而十六进制有前导0x.
6.数组被表示为对某个内存结构的引用，该内存结构中包含数组的长度、元素的数据和一些客户端无法访问的附加信息。
7.Java中，int 4字节，float 4字节，double 8字节 long 8字节
8.可变长参数列表
private int max(int n1,int...args){
int res=n1;
for(int n:args){
if(res<n) res=n;
}
return res;
}
如果调用max(3,17,42,19)，则返回42.
注意args绑定了17，42，19的数组。
ArrayList类
import java.until.ArrayList;
9.声明ArrayList对象(构造器)：
ArrayList<String> list=new ArrayList<String>();
10.常用方法
| 方法 | 功能 |
|---|---|
| size() | 返回数量 |
| isEmpty() | 如果ArrayList空则返回true |
| get(index) | 返回索引的值 |
| get(index,value) | 将索引的值设置为新值 |
| add(value) | 末尾加值 |
| add(index,value) | 在指定索引前插入新值 |
| remove(index/value) | 移除 |
| clear | 清除 |
包装器类
这些类定义在java.lang包中
11.ArrayList类对于存储String类或者其他Java类的值非常合适，但是无法直接使用int,double基本类型。基本类型不是对象，而ArrayList的值必须是对象。
| 基本类型 | 包装器类 |
|---|---|
| boolean | Boolean |
| float | Float |
| double | Double |
| int | Integer |
| long | Long |
| char | Character |
12.声明
Integer a=new Integer(n);
创建Integer对象，内部值为n，赋给了变量a。
引用他的值
a.value();
所以这样可以使用ArrayList类了
ArrayList<a> m;
13.自动装箱：当Java编译器发现我们试图将Int类型的值赋给Integer类型时，会自动创建一个Integer对象，反过来也成立。
所以可以用==与！=用于对象，检查运算符两侧的操作数是否引用了同一个对象。
14.静态方法：
| 方法 | 功能 |
|---|---|
| Integer.paseInt(string,base(可省略)) | 将字符串转换为整数，如果有数基则进行转换 |
| Integer.toString(number,base(可省略)) | 将数字转换为字符串形式 |
int x =Integer.parseInt("9");//然后引用x
栈抽象
栈在编程中很重要，主要原因是嵌套函数调用的行为方式就是面向栈的方式。
Stack也是一个指定元素类型的集合类。
声明同上
15.主要方法
| 方法 | 功能 |
|---|---|
| size() | 元素数量 |
| isEmpty() | 栈空返回true |
| push(value) | 将value压入栈，使它成为顶部 |
| pop() | 出栈 |
| peek() | 返回最顶部的栈 |
| clear() | 清除所有元素 |
队列抽象
16.注意，Stack是类，但是Queue是一个接口，在Java中，接口时一种数据结构的定义，刻画了操作但是没有顶层的表示形式。接口指定了其他实现该接口的类的行为。
Queue接口的具体类，一般常见的是ArrayDeque(双端队列)和LinkedList.
声明：
Queue<Integer> queue=new ArrayDeque<Integer>();
17。主要方法
| 方法 | 功能 |
|---|---|
| size() | 数量 |
| isEmpty() | 空为true |
| add(value) | 入队 |
| remove() | 出队 |
| peak | 返回队首 |
映射表抽象
18.Map是一个接口，所以同样要用类来构建对象。主要有HashMap和TreeMap
Map<String,String> dict=new TreeMap<String,String>();
19.主要方法
| 方法 | 功能 |
|---|---|
| put(key,value) | 将key与value关联，如果没有key那么会添加一项 |
| get(key) | 返回该映射表当前与key关联的值 |
| remove(key) | 删除key及相关联的值 |
| containsKey(key) | 如果key与某个值关联则返回 |
迭代器
20.迭代元素对任何集合类来说是基础操作。
Set<String> english=new Treeset<String>();
for(String word:english){
if(word.length()==7){
System.out.println(word);
}
}
部分习题选讲
这一部分还有许多习题值得去做，在这里仅挑选非常重要的来讲，下次更新更多很好的题目。
ArrayList反序
题目：使用ArrayList以反序显示文件中各行
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;
public class ReverseFile {
public void run() {
Scanner sysin = new Scanner(System.in);
try {
BufferedReader rd = openFileReader(sysin, "Input file: ");
ArrayList<String> lines = readEntireFile(rd);
rd.close();
for (int i = lines.size() - 1; i >= 0; i--) {
System.out.println(lines.get(i));
}
} catch (IOException ex) {
throw new RuntimeException(ex.toString());
}
}
private ArrayList<String> readEntireFile(BufferedReader rd) {
try {
ArrayList<String> lines = new ArrayList<String>();
while (true) {
String line = rd.readLine();
if (line == null) break;
lines.add(line);
}
return lines;
} catch (IOException ex) {
throw new RuntimeException(ex.toString());
}
}
private BufferedReader openFileReader(Scanner sysin, String prompt) {
BufferedReader rd = null;
while (rd == null) {
try {
System.out.print(prompt);
String name = sysin.nextLine();
rd = new BufferedReader(new FileReader(name));
} catch (IOException ex) {
System.out.println("Can't open that file.");
}
}
return rd;
}
/* Main program */
public static void main(String[] args) {
new ReverseFile().run();
}
}
RPN计算器（栈）
题目描述：逆波兰标记法输入表达式（RPN），使用java来编写此程序。
import java.util.Scanner;
import java.util.Stack;
public class RPNCalculator {
public void run() {
Scanner sysin = new Scanner(System.in);
System.out.println("RPN Calculator Simulation (type H for help)");
Stack<Double> operandStack = new Stack<Double>();
while (true) {
System.out.print("> ");
String line = sysin.nextLine();
char ch = Character.toUpperCase(line.charAt(0));
if (ch == 'Q') {
break;
} else if (ch == 'C') {
operandStack.clear();
} else if (ch == 'H') {
helpCommand();
} else if (Character.isDigit(ch)) {
operandStack.push(Double.parseDouble(line));
} else if (ch == '+' || ch == '-' || ch == '*' || ch == '/') {
applyOperator(ch, operandStack);
} else {
System.out.println("Unrecognized command " + ch);
}
}
}
private void helpCommand() {
System.out.println("Enter expressions in Reverse Polish Notation,");
System.out.println("in which operators follow the operands to which");
System.out.println("they apply. Each line consists of a number, an");
System.out.println("operator, or one of the following commands:");
System.out.println(" Q -- Quit the program");
System.out.println(" H -- Display this help message");
System.out.println(" C -- Clear the calculator stack");
}
private void applyOperator(char op, Stack<Double> operandStack) {
double result;
double rhs = operandStack.pop();
double lhs = operandStack.pop();
switch (op) {
case '+': result = lhs + rhs; break;
case '-': result = lhs - rhs; break;
case '*': result = lhs * rhs; break;
case '/': result = lhs / rhs; break;
default: throw new RuntimeException("Undefined operator " + op);
}
System.out.println(result);
operandStack.push(result);
}
/* Main program */
public static void main(String[] args) {
new RPNCalculator().run();
}
}
计算词频（Map）
题目描述：编写一个java程序，使得计算输入文件每个单词的出现次数。
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;
public class WordFrequency {
public void run() {
Scanner sysin = new Scanner(System.in);
try {
BufferedReader rd = openFileReader(sysin, "Input file: ");
Map<String,Integer> wordCounts = new TreeMap<String,Integer>();
while (true) {
String line = rd.readLine();
if (line == null) break;
countWords(line, wordCounts);
}
rd.close();
displayCounts(wordCounts);
} catch (IOException ex) {
throw new RuntimeException(ex.toString());
}
}
private void countWords(String line, Map<String,Integer> wordCounts) {
String word = "";
for (int i = 0; i < line.length(); i++) {
char ch = line.charAt(i);
if (Character.isLetter(ch)) {
word += Character.toLowerCase(ch);
} else {
if (!word.isEmpty()) {
incrementCount(word, wordCounts);
word = "";
}
}
}
if (!word.isEmpty()) incrementCount(word, wordCounts);
}
/*
* Increments the count for word in the map.
*/
private void incrementCount(String word, Map<String,Integer> wordCounts) {
if (wordCounts.containsKey(word)) {
wordCounts.put(word, wordCounts.get(word) + 1);
} else {
wordCounts.put(word, 1);
}
}
/*
* Displays the word count along with the word.
*/
private void displayCounts(Map<String,Integer> wordCounts) {
for (String word : wordCounts.keySet()) {
System.out.printf("%4d %s%n", wordCounts.get(word), word);
}
}
private BufferedReader openFileReader(Scanner sysin, String prompt) {
BufferedReader rd = null;
while (rd == null) {
try {
System.out.print(prompt);
String name = sysin.nextLine();
rd = new BufferedReader(new FileReader(name));
} catch (IOException ex) {
System.out.println("Can't open that file.");
}
}
return rd;
}
/* Main program */
public static void main(String[] args) {
new WordFrequency().run();
}
}
总结
此次java学习结合了重要的数据结构来进行讲解，可以很直观的发现java与C++异同。然而对于java的学习理解这些还远远不够，这些也只是最基础的部分，尽管后期书籍以算法讲解较多，但是涉及java的框架还是谈的比较少，所以在后期的学习中，应该加大java的实战项目经验，通过前后端的连接来理解java的重要性！