Java-J2SE常用的类和方法复习

摘要: Java J2SE 常用的类和方法

1、随机数

public static void main(String[] args) {
//Math.random()会得到一个0-1之间double类型的值
System.out.println(Math.random());
//获取[0-9]之间的整数
System.out.println((int)(Math.random()*10));
for(int i=0;i<100;i++) {
System.out.println(randomRange(18,28));
}
}

//获取两个数之间的随机数
public static int randomRange(int start,int end) {
return (int)(Math.random()*(end-start)+start);
}

2、Object：所有类都默认继承Object

2.1、toString()方法

当输出对象时会自动调用该对象的toString()方法打印信息，如果希望按照自己的需求进行对象信息的显示，可以在子类中覆盖父类的toString()方法。

System.out.println(p2.toString());
//说明输出对象的时候，会自动调用对象的toString()方法
//输出id：XXX,name:XXX,直接在子类中覆盖toString()方法即可
System.out.println(p);

class Person {
int id;
String name;

public Person(int id, String name) {
super();
this.id = id;
this.name = name;
}

@Override
public String toString() {
return "id:"+id+",name:"+name;
}

2.2、equals()

使用equals()方法可以比较两个对象是否相等，如果子类没有覆盖父类的equals()方法，会默认调用==进行比较。

String str3 = new String("456");
String str4 = new String("456");
//==表示两个引用是否指向同一块内存
System.out.println(str3==str4);
//比较两个字符串的值是否相等
//String可以通过equals()比较两个对象的内容是否相等，是因为
//String覆盖了父类的equals()方法
System.out.println(str3.equals(str4));

class Person {
int id;
String name;

public Person(int id, String name) {
super();
this.id = id;
this.name = name;
}

@Override
public String toString() {
return "id:"+id+",name:"+name;
}

@Override
public boolean equals(Object obj) {
Person person = (Person)obj;
return this.id==person.id;
}

比较两个对象是否相等，首先需要覆盖equals()方法还要覆盖hashCode()方法。

@Override
public boolean equals(Object obj) {
Person person = (Person)obj;
//return this.id==person.id;
//判断name相同两个person对象就相同
return this.name.equals(person.name);
}

@Override
public int hashCode() {
//return id;
return name.hashCode();
}

main函数

main函数中的args参数用来在运行时传入一些值改变其函数的方法。

//args用来存储运行时的参数，可以在运行时指定相应的参数，使用空格来分分隔
public static void main(String[] args) {
/*
System.out.println(args.length);
for(String arg:args) {
System.out.println(arg);
}
*/

try{
//字符串转换为int
//转换时会抛出相应的NumberFormatException异常
int r = Integer.parseInt(args[0])+Integer.parseInt(args[1]);
System.out.println(r);
}catch (NumberFormatException e)
{
System.out.println("请输入正确的参数");
}

String

String内存

String str1 = new String("123");
String str2 = new String("123");
//str1和str2指向不同的内存
System.out.println(str1==str2);
System.out.println(str1.equals(str2));

String str3 = "123";
String str4 = "123";
System.out.println(str3==str4);//str3和str4指向同一块内存
System.out.println(str3.equals(str4));

str3 = "234";
str4 = "456";
str4 = "789";
String str5 = "456";

/**
* 由于String是字符串常量，每新建一个字符串就会分配一块内存
* 此时以下循环会分配100块内存，但是只有在最后一块被使用，
* 而且String pool中的内存不会被回收，
* 所以如果进行大量字符串叠加，请不要使用以下方法
*/
String str6 = "";
for(int i=0;i<100;i++) {
str6+=i;
}
System.out.println(str6);

StringBuilder:使用StringBuilder来连接字符串

StringBuilder sb = new StringBuilder("abc");
for(int i=0;i<100;i++) {
//使用append()连接
sb.append(i);
}
System.out.println(sb);

String str1 = "123";
String str2 = "456";
String str3 = "789";
StringBuilder sb1 = new StringBuilder();
//StringBuilder支持链式编程
sb1.append(str1).append(str2);
//sb1和sb2指向同一块内存
StringBuilder sb2 = sb1;
sb2.append(str3);
System.out.println(sb1);

String的常用方法

String word = "hello kk , welcome to china";
//通过字符串将其拆分为数组
String[] strs = word.split(" ");
System.out.println(strs.length);
for(String str:strs) {
System.out.println(str);
}
String user = "系统管理员，文章发布人员，系统用户";
String[] rs = user.split("，");
for(String r:rs) {
System.out.println(r);
}

//希望获取一个文件的后缀-->h.txt
String str = "sad.sah.txt";
//1、截取子串:开始包含，结束不包含
System.out.println(str.substring(0,2));
//2、获取某个字符串的位置，从0开始，如果字符串不存在返回-1
System.out.println(str.indexOf("sdcs"));
//从后向前获取某个字符串的位置，如果不存在返回-1
System.out.println(str.lastIndexOf("."));

System.out.println(str.substring(str.indexOf(".")+1));
System.out.println(str.substring(str.lastIndexOf(".")+1));
System.out.println(getFileType(str));

文件名的处理

private static List<String> accTypes = Arrays
.asList("jpg","bmp","gif","doc","docx","rar","xls","xlsx");

public static void main(String[] args) {
for(String str:args) {
//判断文件是否可以传入
if(accTypes.contains(getFileType(str))) {
System.out.println("可以传入的类型："+str);
} else {
System.out.println("不可以传入的类型："+str);
}
}
}

//获取文件的后缀名
public static String getFileType(String filename) {
int pos = filename.indexOf(".");
if(pos==-1) {
return null;
}
return filename.substring(pos+1);
}

日期的处理

try {
//定义一种日期的显示格式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
Date d = new Date();
//将日期对象格式化为一个字符串对象，按照SimpleDateFormat中设置的格式
System.out.println(sdf2.format(d));
//创建一个日期的字符串对象
String str = "1979-2-12 12:22:34";
//将字符串转换为日期，使用sdf中的格式，注意如果格式不符，会抛出异常
System.out.println(sdf.parse(str));
} catch (ParseException e) {
e.printStackTrace();
}

try {
Date d = new Date();
//通过1970-1-1 0:0来计算到今天的毫秒数
System.out.println(d.getTime());
long times = d.getTime();
System.out.println(times);

String olp = "2016-6-18";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
long endTime = sdf.parse(olp).getTime();
//通过两个time可以获取两个时间的差别，得到的是毫秒数
long st = endTime-times;
System.out.println(st/(1000*60*60*24));
} catch (ParseException e) {
e.printStackTrace();
}

Collections

List<String> songs = new ArrayList<String>();
//快速添加列表
Collections.addAll(songs, "明天会更好","怒放的生命","飞得更高","相信自己","明天的明天");
//为列表排序
Collections.sort(songs);
//随机排序
//Collections.shuffle(songs);
Collections.reverse(songs);

Collections.swap(songs, 2, 4);
printList(songs);

对象排序1

//要进行Collections的排序，对象得实现Comparable接口，
//并且覆盖CompareTo()方法
class Song implements Comparable<Song> {

private int id;
private String name;
private String songer;

public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSonger() {
return songer;
}
public void setSonger(String songer) {
this.songer = songer;
}

public Song(int id, String name, String songer) {
super();
this.id = id;
this.name = name;
this.songer = songer;
}

public Song() {
super();
}

@Override
public String toString() {
return "Song [id=" + id + ", name=" + name + ", songer=" + songer + "]";
}

@Override
public int compareTo(Song o) {
/*
* 说明：
* 拿this来和o比较，如果返回1表示this比0大，如果返回-1表示this比0小，
* 如果返回0表示一样大
*/
//会使用this和o比较，如果返回的值>1表示顺序排序，返回值是<1的数表示倒序
//		if(this.id>o.id) return 1;
//		else if(this.id<o.id) return -1;
//		else return 0;

//		return this.getName().compareTo(o.getName());
return this.getSonger().compareTo(o.songer);
}

这种方法的排序仅仅只能针对一个属性排序，如果希望根据其它属性排序，需要修改CompareTo()方法。

对象排序2

//实现Comparator接口，可以专门针对一个对象写多种排序方式，
//compare()方法中的两个对象可以把第一个参数看作this，
//第二个参数看作o
class SongNameCompare implements Comparator<Song> {

@Override
public int compare(Song o1, Song o2) {
return o1.getName().compareTo(o2.getName());
}

}

class SongerCompare implements Comparator<Song> {

@Override
public int compare(Song o1, Song o2) {
return o1.getSonger().compareTo(o2.getSonger());
}

}

class IdCompare implements Comparator<Song> {

@Override
public int compare(Song o1, Song o2) {
return o1.getId()>o2.getId()?1:(o1.getId()<o2.getId()?-1:0);
}

}

List<Song> songs = new ArrayList<Song>();
songs.add(new Song(111,"爱你一万年","刘德华"));
songs.add(new Song(1121,"忘情水","刘德华"));
songs.add(new Song(222,"吻别","张学友"));
songs.add(new Song(232,"一千个伤心的理由","张学友"));
songs.add(new Song(33,"突然的自我","伍佰"));
songs.add(new Song(34,"挪威森林","伍佰"));
songs.add(new Song(44,"心太软","任贤齐"));
songs.add(new Song(55,"有多少爱可以重来","迪克牛仔"));

//传递一个实现了Comparator接口的实现类，来在运行时进行排序
//		Collections.sort(songs, new SongNameCompare());
//		Collections.sort(songs, new SongerCompare());
Collections.sort(songs, new IdCompare());

JTable的使用

1、常规的方式

常规的方式就是定义表格表头和表格的元素

其中表格的表头使用一个Vector的列表来存储

表格中的元素使用一个Vector来存储，Vector中的每一个元素还是一个Vector

//放置每一列的名称
Vector<String> columnNames = new Vector<String>();
columnNames.add("用户名");
columnNames.add("用户密码");
columnNames.add("用户昵称");
//放置表格中的元素
Vector<Vector<String>> rowData = new Vector<Vector<String>>();
//表格中的每一行的数据
Vector<String> ue = new Vector<String>();
ue.add("ts");
ue.add("123");
ue.add("唐僧");
rowData.add(ue);
ue = new Vector<String>();
ue.add("wk");
ue.add("123");
ue.add("悟空");
rowData.add(ue);
ue = new Vector<String>();
ue.add("bj");
ue.add("123");
ue.add("八戒");
rowData.add(ue);
ue = new Vector<String>();
ue.add("ss");
ue.add("123");
ue.add("沙僧");
rowData.add(ue);
jt = new JTable(rowData,columnNames);
jsp = new JScrollPane(jt);
this.add(jsp);

2、基于TableModel的模式

定义一个类继承AbstractTableModel

@SuppressWarnings("serial")
public class MyTableModel extends AbstractTableModel {
Vector<String> columnNames;
Vector<Vector<String>> rowData;

初始化数据

和常规的方式类似，进行数据的初始化操作

//同样需要列和行
Vector<String> columnNames;
Vector<Vector<String>> rowData;

public MyTableModel() {
columnNames = new Vector<String>();
rowData = new Vector<Vector<String>>();
initData();
}

//和常规的操作一样进行数据的初始化操作
private void initData() {
columnNames.add("用户名");
columnNames.add("用户密码");
columnNames.add("用户昵称");
Vector<String> ue = new Vector<String>();
ue.add("ts");
ue.add("123");
ue.add("唐僧");
rowData.add(ue);
ue = new Vector<String>();
ue.add("wk");
ue.add("123");
ue.add("悟空");
rowData.add(ue);
ue = new Vector<String>();
ue.add("bj");
ue.add("123");
ue.add("八戒");
rowData.add(ue);
ue = new Vector<String>();
ue.add("ss");
ue.add("123");
ue.add("沙僧");
rowData.add(ue);
}

覆盖几个基本的方法

//返回一个行的数量
@Override
public int getRowCount() {
return rowData.size();
}
//返回一个列的数量
@Override
public int getColumnCount() {
return columnNames.size();
}
//获取某一行某一列的值
@Override
public Object getValueAt(int rowIndex, int columnIndex) {
return rowData.get(rowIndex).get(columnIndex);
}
//说明每一列的名称
//该方法不是必须覆盖的，如果不覆盖，表格的表头就是A,B,C
@Override
public String getColumnName(int column) {
return columnNames.get(column);
}

创建表格时使用自己定义的Model

jt = new JTable(new MyTableModel());