整理三

整理三

编译文件命令：

javac -d 存放位置 要编译的Java文件

运行文件：

java 包名.类名

关键字：

在Java中有特殊含义的单词 --- 53个，2个保留字：goto、const --- 所有的关键字都是小写

标识符：

在Java中自定义的名称 --- 可以是字母、数字、_、$组成，数字不能开头，不能使用关键字，大小写敏感，见名知意

++/--自增/自减

在变量之前要先自增后运算；在变量之后先运算后自增

交换值的方式

方式一：亦或法

int x =5, y = 7;

x = x ^ y;

y = x ^ y; -> y = x ^ y ^ y; -> y = x; -> y = 5;

x = x ^ y; -> x = x ^ y ^ x; -> x = y; -> x = 7;

方式二：加减法

int x = 3, y = 7;

x = x + y;

y = x - y; -> y = x + y - y; -> y = x; -> y = 3;

x = x - y; -> x = x + y - x; -> x = y; -> x = 7;

方式三：追尾法

int x = 3, y = 7;

int z = x;

x = y;

y = z;

扩展：考虑三种方式的优劣性

亦或法的效率最高的，但是它的使用频率最低 --- 只能适用于整数值的交换

加减法的效率低于亦或法但是高于追尾法 --- 理论上适用于数值型

追尾法的效率最低的，但是它的使用频率最高 --- 适用于所有的类型

静态变量 --- 类变量。

随着类的加载而加载到方法区，并且在方法区被赋予默认值。静态变量比对象先出来。这个类产生的所有的对象用的是这个静态变量在方法区中的地址，所以静态变量是被所有对象所共享的

静态方法 --- 类方法。

在类加载的时候加载到方法区，只是存储在方法区中并不执行，在被调用的时候到栈内存中执行。静态方法比对象先出来。静态可以重载，可以被继承，不能被重写，然而父子类中可以存在方法签名一致的静态方法---隐藏 --- 父子类中存在方法签名一致的方法的时候，要么都是非静态，要么都是静态

静态代码块

用static{}定义。在类加载的时候执行 --- 类只加载一次，所以静态代码块也只执行一次。

&&：

运算规则和&一致的。如果前边的表达式的结果是false，则后边的表达式就不再运算，整个结果确定为false

||：

运算规则和|一致的。如果前边的表达式的结果是true，则后边的表达式就不再计算，而整个结果确定为true

||在&&前边的时候能够把&&给短路掉，但是&&在||前边，不能短路掉||

Java中文件输入输出

 在Java中，可以通过流来实现文件的读写操作

数据由程序流向文件 - > 输出流；数据由文件流向程序 - > 输入流

字符流在汉字的处理方面比字节流更加的高效

字符流底层也是通过字节流来实现的，因此通过字符流来操作的一定可以通过字节流来操作

jdk8的新特性

 jdk8开始，接口中允许定义实体方法。

 jdk8开始，switch 语句可以用字符串

 jdk8开始，支持Lambda表达式

 Lambda表达式中，当方法体只有一句话时，可以省略return语句。

JDK1.5新特性：

1、自动封箱/拆箱

2、增强for循环

3、静态导入

4、可变参数、

5、枚举

6、泛型

7、动态代理

8、注解

JDK1.7新特性：

1、在数据前加OB/b表示二进制数据

2、正数允许使用_分位 1_000_015

3、switch-case：允许使用String

4、异常的分组:  |

5、泛型的推导：<>

6、try(定义)catch(){}

关于泛型

在jdk1.7之前没有泛型。

<? extends 类或者接口> 可以向下划定范围

<? super 类或者接口> 可以向上划定范围

在编译的时候，泛型会被指定的类型替代，称之为泛型的擦除。

关于程序总结

1.日期和字符串之间的转换，要求如下：

 1)日转换为字符串

 2)字符串转换为日期

思路：

定义日期的格式；通过parse/format方法

关键技术：

通过类SimpleDateFormat 调用parse/format方法

 

1     String str = "2018-07-30 10:25:21";
2     SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
3     Date day = sdf.parse(str);
4     System.out.println(day);
5     SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy年MM月dd日 yyyy年 mm月dd日 HH时mm分ss秒");
6     String str1 = sdf1.format(day);
7     System.out.println(str1);    

 

请用List<String>来实现一个Stack<String>，要求如下：

1)实现其中的push方法，要求每次添加元素都是添加到栈顶位置（即List中下标为0的位置）

2)实现其中的peek方法，查看栈顶元素

3)实现其中的pop方法，获取并移除栈顶元素

4)实现其中的empty方法，测试栈是否为空

 1 class Stack {
 2     
 3     //用于储存栈内元素
 4     private List<String> data = new ArrayList<>();
 5     //栈大小
 6     private int size = 0;
 7     
 8     //入栈
 9     public void push(String str){
10         // 判断入栈参数是否为空，为空抛出异常
11         if(str == null){
12             throw new NullPointerException();
13         }
14         // 判断栈是否为空
15         if(size == 0){
16             // 为空直接添加
17             this.data.add(0, str);
18             // 栈大小+1
19             size ++;
20         }else{
21             // 若栈内本来就有元素
22             // 先将新入栈元素放入一个新的list
23             // 再将栈内原来的元素依次放入list中
24             // 将list赋值给data
25             List<String> list = new ArrayList<>();
26             list.add(str);
27             for(int i = 0;i < size;i ++){
28                 list.(i));
29             }
30             size ++;
31             data = list;
32         }
33     }
34     
35     // 获取栈顶元素
36     public String peek(){
37         // 获取data集合下标0对应的元素
38         (0);
39     }
40     
41     // 获取栈顶元素并移除
42     public String pop(){
43         // 获取栈顶元素
44         String a = (0);
45         // 移除集合中下标为0的元素
46         ve(0);
47         size--;
48         return a;
49     }
50     
51     // 判断栈是否为空
52     public boolean empty(){
53         return size <= 0;
54     }
55     
56     public String toString(){
57         String str = "";
58         StringBuffer sb = new StringBuffer("[");
59         for(int i = 0;i < size;i++){
60             sb.(i)+",");
61         }
62         if(size != 0){
63             str = sb.toString();
64             str = str.substring(0,str.length()-1);
65         }
66         str += "]";
67         return str;
68     }
69 }

创建一个多线程的TCP 服务器以及客户端，完成下面的功能：

已知在服务器端的目录下有一个,其格式如下：

2006/意大利

2002/巴西

...

该文件采用"年份/世界杯冠军 "的方式保存每一年世界杯冠军的信息。

要求从客户端输入年份，从服务器端查询，若查询到，返回举办地；反之，返回"未查询到该年份的世界杯举办地"。

客户端：

 1             try {
 2             // 创建客户端套接字对象
 3             Socket s = new Socket();
 4             // 新建输入对象
 5             Scanner s1 = new Scanner(System.in);
 6             // 获取输入数据
 7             String str = s1.nextLine();
 8             // 请求连接
 9             s.connect(new InetSocketAddress("localhost", 8888));
10             // 获取套接字Socket自带的输出流
11             OutputStream out = s.getOutputStream();
12             // 将输入的数据发送给服务器端
13             out.Bytes());
14             // 告诉服务器端数据已经写出完毕
15             s.shutdownOutput();
16             
17             // 获取套接字对象s自带的输入流
18             InputStream in = s.getInputStream();
19             // 新建数组作为输入流的缓冲区
20             byte[] bs = new byte[1024];
21             // 初始化输入流读入数据长度
22             int len = -1;
23             // 读数据并输出
24             while ((len = in.read(bs)) != -1) {
25                 System.out.println(new String(bs, 0, len));
26             }
27             // 读数据结束
28             s.shutdownInput();
29             // 关流
30             s.close();
31             out.close();
32             in.close();
33         } catch (IOException e) {
34             e.printStackTrace();
35         }        

服务器端：

 1                // 一直接收数据
 2         while(true){
 3             
 4             try {
 5                 // 创建服务器端的套接字对象，并绑定端口号
 6                 ServerSocket ss = new ServerSocket(8888);
 7                 // 接受连接
 8                 Socket s = ss.accept();
 9                 // 获取Socket自带的输入流
10                 InputStream in = s.getInputStream();
11                 
12                 // 读取数据客户端发来的数据
13                 byte[] bs = new byte[1024];
14                 int len = -1;
15                 String str = "";
16                 while((len = in.read(bs)) != -1){
17                     str = new String(bs,0,len);
18                 }
19                 // 通知客户端数据已经读取完了
20                 s.shutdownInput();
21                 
22                 // 新建文件读取流并指向文件
23                 File file = new File(&#");
24                 // 利用FileRReader来构建了BufferedReader
25                 FileReader fr = new FileReader(file);
26                 BufferedReader br = new BufferedReader(fr);
27                 
28                 String str1 = "";
29                 // 获取套接字Socket自带的输出流
30                 OutputStream out = s.getOutputStream();
31                 // 逐行读取文件
32                 while((str1 = br.readLine()) != null){
33                     // 每行数据按照/截取字符串，并赋值给数组
34                     String[] strs = str1.split("/");
35                     if(str.equals(strs[0])){
36                         str1 = strs[1];
37                         break;
38                     }
39                 }
40                 if(str1 == null){
41                     str1 = "未查询到该年份的世界杯举办地";
42                 }
43                 out.Bytes());
44                 // 关流
45                 ss.close();
46                 in.close();
47                 out.close();
48                 br.close();
49                 fr.close();
50             } catch (IOException e) {
51                 e.printStackTrace();
52             }
53         }

转载于:.html