【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的重要性!

你可能感兴趣的:(Java,java,开发语言,后端)