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） 对象数组排序

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

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{

	@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());
		}
	}

}
 
  
 测试： 
  
 
  
 
  
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： 
  
 
  
 
  
package com.yrs.app.test;

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

public class MpnTable {
	
	private Map map;
	
	public MpnTable() {
		map = new HashMap();
		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();

	}

}