NIIT 实训 java笔记--3.21

1, 数组

int [] a = null;

a是基本数据类型的数组，但它的类型是引用数据类型。

初始化

int[] a = newint [5]

int[] a = newint [] {1,2,3,4,5}

int[] a ={1,2,3,4,5}

遍历数组中所有元素

for(int i = 0; i< a.length; i++) {

........

}

//增强型的for循环， foreach循环

//对于数组（或集合）a，每次循环都获取一个元素，并把这个元素变量命名为i

//一般用于只读的数据呈现

For(int i : a) {

........

}

数组的长度一旦初始化后就固定了

2，集合

集合的大小可以改变

集合中的数据类型全都是引用数据类型，（添加基本数据类型值时，存在自动装箱的过程）。

Set: 元素不能重复（equals为true才认为是重复的），

HashSet: 元素不按顺序排列（实际上顺序是按照对象值的hash值来排序的）

TreeSet: 元素会自动排序，如果元素没有实现排序接口则会有异常

List： 元素可以重复，且顺序同添加的顺序

ArrayList: 线程不安全

Vector：线程安全

数组长度 length 属性

字符串长度 length() 方法

集合长度 size() 方法

Map （类似其他语言中的字典）

映射

键值对 key value

3， 泛型

为什么使用泛型？

1，省去了编译器去决定类型的过程，提升性能

2，避免不正确的类型比较，提升安全

4，练习

（1） 对象数组排序

这个例子是实现了，游戏玩家分数排序，若分数相同，按玩家名字从低到高排序

<pre name="code" class="java">package com.yrs.app.entity;

public class Player {
//玩家类
private String name;
private Integer score;

public Player() {
// TODO Auto-generated constructor stub
}

public Player(String name, Integer score) {
this.name = name;
this.score = score;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public Integer getScore() {
return score;
}

public void setScore(Integer score) {
this.score = score;
}

}

实现Comparator接口：

package com.yrs.app.util;

import java.util.Comparator;

import com.yrs.app.entity.Player;

public class ScoreCompare implements Comparator<Player>{

@Override
public int compare(Player p1, Player p2) {
if(p1.getScore() > p2.getScore()) {
return -1;
}
else if(p1.getScore() < p2.getScore()) {
return 1;
}
else {
return p1.getName().compareTo(p2.getName());
}
}

}

测试：

<pre name="code" class="java">package com.yrs.app.test;

import java.util.Arrays;

import com.yrs.app.entity.Player;
import com.yrs.app.util.ScoreCompare;

public class ScoreSort {
public static void main(String[] args) {
Player player1 = new Player();
player1.setName("A");
player1.setScore(90);

Player player2 = new Player();
player2.setName("B");
player2.setScore(60);

Player player3 = new Player();
player3.setName("C");
player3.setScore(90);

Player player4 = new Player();
player4.setName("D");
player4.setScore(30);

Player player5 = new Player();
player5.setName("E");
player5.setScore(66);

Player [] pyrArr = {player1, player2, player3, player4, player5};
//由于我们实现了Comparator接口，所以可以调用Arrays的sort排序方法
Arrays.sort(pyrArr, new ScoreCompare());

for(Player p: pyrArr) {
System.out.println(p.getName() + " " + p.getScore());
}

}

}

（ 2）输出九九乘法表

练习使用Map：

<pre name="code" class="java">package com.yrs.app.test;

import java.util.HashMap;
import java.util.Map;

public class MpnTable {

private Map<Integer, String> map;

public MpnTable() {
map = new HashMap<Integer, String>();
String [] chinese = {"一", "二",  "三", "四", "五", "六", "七", "八", "九"};
for(int i=1; i<10; i++) {
map.put(i, chinese[i-1]);
}
}

public void printTable () {
for(int i = 1; i <= 9; i++) {
for(int j = 1; j <= i; j++)  {
getChineseChar(i, j, i*j);
}
System.out.println();
}
}

public void getChineseChar(int i, int j, int result) {
if(result < 10) {
System.out.printf("%s%s得%s\t",map.get(j), map.get(i), map.get(result));
//使用以下这条语句，性能上不如上面这句，因为每get一个返回一个字符串，相加后又有新的字符串生成，会占用空间
//System.out.print(map.get(j) + map.get(i) + map.get(0) + map.get(result) + "\t");
}
else if(result > 10 && result < 20) {
System.out.printf("%s%s十%s\t", map.get(j), map.get(i), map.get(result - 10));
}
else if(result % 10 == 0) {
System.out.printf("%s%s%s十\t", map.get(j), map.get(i), map.get(result/10));
}
else {
System.out.printf("%s%s%s十%s\t", map.get(j), map.get(i), map.get(result/10), map.get(result % 10));
}
}

public static void main(String[] args) {
new MpnTable().printTable();

}

}