Java基础零碎练手<二>

1、接口的测试

        //interface接口的测试，接口无论在哪里是何种语言，都是重点，项目开发无处不在，多体会！

interface singer{
public static final int i = 0;
public void singing();     //默认的abstruct的；
}
interface runner{
public void start();
}

interface dancer extends singer{  //接口的继承 接口可以继承接口
public void dance();
}

abstract class teacher{    //抽象类
abstract public void teach();
public void fun(){};
}

class students implements singer{  //
private String name;
students(String _name)
{
name = _name;
}
public void singing()
{
System.out.println("students are singing!");
}
public void sleep()
{
System.out.println("students are sleeping!");
}
}
class performer extends teacher implements singer,runner{ //一个类可以实现多个接口；
public void teach()
{
System.out.println("extends:performer is a singer!");
}
public void singing()
{
System.out.println("interface singer implements ");
}
public void start()
{
System.out.println("runner: start implements");
}
}

class dancezhang implements dancer {
public void dance() {
System.out.println("dancezhang: implements dancer::dance");
}

public void singing() {
System.out.println("dancezhang: implements singer::singsing ");
}

void fthrow() throws FileNotFoundException {
System.out.println("throw in function!");
}
}
main：
singer sin = new performer();
sin.singing();

runner run = (runner) sin; //类型的转换；窗口的变换；
run.start();              //调用run的方法；

dancer lili = new dancezhang();
lili.dance();

singer yan = (singer) lili; //伴随着多态；
yan.singing();

2、equals和hashCode方法

   class Name{
        String Firstname;
        String lastname;

        Name(String _Firstname, String _lastname)
        {
            this.Firstname = _Firstname;
            this.lastname = _lastname;
        }

        public boolean equals(Object obj) {
            if (obj instanceof Name) {
                Name na = (Name) obj;
                return ((Firstname.equals(na.Firstname)) && (lastname.equals(na.lastname)) );
            }
            return  super.equals(obj);
        }

        public int hashCode()  //一般情况下，重写equals,必须重写hashCode；
        {
            return Firstname.hashCode();  //说明两个对象相等必须要有两个相等的hash码；
        }
    }

     ==用于比较引用和比较基本数据类型时具有不同的功能：

     比较基本数据类型，如果两个值相同，则结果为true

     而在比较引用时，如果引用指向内存中的同一对象，结果为true）

     区别：

     而equals()作为方法，默认的是比较地址，和==的效果是一样的，其底层是用==号实现的；我们可以推测知道，它其中的实现所使用的肯定是==运算符。再进一步的思考，

     equals()本意不正是==运算符进行对象比较时候的作用吗。那么，既然是两者有同样的作用，为什么还要弄出一个equals()方法来呢。
     因为==运算符不允许我们进行覆盖，也就是说它限制了我们的表达。

     我们复写equals()方法，达到比较对象内容是否相同的目的。而这些通过==运算符是做不到的。

     String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址了；

     Object中的equals： 

public boolean equals(Object obj) {
return (this == obj);
}

   Integer中的 equals：

  

public boolean equals(Object obj) {
if (obj instanceof Integer) {
return value == ((Integer)obj).intValue();
}
return false;
}

（1）.equals()是Object的类，是一切类的方法！

（2）.如果不重写equals的话，作用是和==是相同的，都是比较的对象的引用；

（3）.我们一般的业务逻辑是需要重写Object的equals方法的，比较的内容就是对象持有的属性了。
3、容器的测试：
Collection

├List

│├LinkedList

│├ArrayList

│└Vector

│└Stack

└Set

Map

├Hashtable

├HashMap

└WeakHashMap
测试代码：

1、ArrayList 容器测试：
ArrayList<Integer> arrayList = new ArrayList<Integer>();
arrayList.add(1);
arrayList.add(2);
arrayList.add(3); //添加元素；
arrayList.set(2,22); //设置元素；
arrayList.remove(0); //删除元素；
arrayList.set(0,1); //替换元素；

Iterator<Integer> iterator = arrayList.iterator();
System.out.println("iterator: ");
while(iterator.hasNext()){
Integer value = iterator.next();
System.out.println(value);
}

System.out.println("for length : ");
Object [] arry = arrayList.toArray(); //转换为数组；

for(int i = 0; i < arry.length; i++){
System.out.println(arry[i]);
}

System.out.println("for size: ");
for(int i = 0; i < arrayList.size(); i++ ){
Integer value = (Integer) arrayList.get(i);
System.out.println(value);
}

System.out.println("OBject: ");
for(Object ob : arrayList){
System.out.println(ob);
}

2、Map的测试：
ArrayList<Integer> arrayList1 = new ArrayList<Integer>();
arrayList1.add(1);
arrayList1.add(2);
arrayList1.add(3);

ArrayList<Integer> arrayList2 = new ArrayList<Integer>();
arrayList2.add(11);
arrayList2.add(22);
arrayList2.add(33);

ArrayList<Integer> arrayList3 = new ArrayList<Integer>();
arrayList3.add(111);
arrayList3.add(222);
arrayList3.add(333);

Map<Integer, String> hashMap = new HashMap<Integer,String>();
hashMap.put(1,"kongyin");
hashMap.put(2,"zhang");
hashMap.put(3,"sheng");
System.out.println("hashMap:");
System.out.println(hashMap);

System.out.println("2: " + hashMap.get(2));
System.out.println(hashMap.containsKey(2));
System.out.println(hashMap.containsValue("zhang"));
System.out.println(hashMap.keySet());
System.out.println(hashMap.isEmpty());

// JDK1.4中
// 遍历方法一 hashmap entrySet() 遍历
System.out.println("方法一");
Iterator it = hashMap.entrySet().iterator();
while (it.hasNext()) {
Map.Entry entry = (Map.Entry) it.next();
Object key = entry.getKey();
Object value = entry.getValue();
System.out.println("key=" + key + " value=" + value);
}

// JDK1.5中,应用新特性For-Each循环
// 遍历方法二
System.out.println("方法二");
for (Map.Entry<Integer,String> entry : hashMap.entrySet()) {
String key = entry.getKey().toString();
String value = entry.getValue().toString();
System.out.println("key=" + key + " value=" + value);
}
System.out.println("");
System.out.println();
System.out.println();
System.out.println();

// 遍历方法三 hashmap keySet() 遍历
System.out.println("方法三");
for (Iterator i = hashMap.keySet().iterator(); i.hasNext();) {
Object obj = i.next();
System.out.println(obj);// 循环输出key
System.out.println("key=" + obj + " value=" + hashMap.get(obj));
}

for (Iterator i = hashMap.values().iterator(); i.hasNext();) {
Object obj = i.next();
System.out.println(obj);// 循环输出value
}
System.out.println("");

// 遍历方法四 treemap keySet()遍历
System.out.println("方法四");
for (Object o : hashMap.keySet()) {
System.out.println("key=" + o + " value=" + hashMap.get(o));
}
// java如何遍历Map <String, ArrayList> map = new HashMap <String,
// ArrayList>();
System.out.println("java 遍历Map <String, ArrayList> map = new HashMap <String, ArrayList>();");
Map<String, ArrayList> map = new HashMap<String, ArrayList>();
map.put("aa",arrayList1);
map.put("bb",arrayList2);
map.put("cc",arrayList3);

System.out.println("values:---- " + map.values());
System.out.println("size: ----" + map.size());
System.out.println("entrySet:----" + map.entrySet());
System.out.println("keySet:---- " + map.keySet());
System.out.println("hashCode: -----" + map.hashCode());

3、set的使用：

Set<Integer> set = new HashSet<Integer>();
set.add(1);
set.add(2);
set.add(3);
set.add(2);

//1.迭代遍历：
Iterator<Integer> it = set.iterator();
while (it.hasNext()) {
Integer str = it.next();
System.out.print(str);
}
System.out.println();

// 2.for循环遍历：
for (Integer str : set) {
System.out.print(str);
}
System.out.println();

// 3.for增强循环遍历
for(Integer value : set){
System.out.print(value+" ");
}

//优点还体现在泛型 假如 set中存放的是Object

Set<Object> set1 = new HashSet<Object>();
// for循环遍历：
for (Object obj: set1) {
if(obj instanceof Integer){
int aa= (Integer)obj;
System.out.println(aa);
}else if(obj instanceof String){
String aa = (String)obj;
}
}

4、深入 foreach 和 for 循环的区别

增强for循环的的使用：

Collection coll = new ArrayList();
coll.add("a");
coll.add("b");

for(Object o : coll)
{
System.out.println(o);
}

//增强的for可循环
int arr[]={1,2,3,4};
for(int i : arr)
{
System.out.println( i );
}

foreach   (var a in GetList())

{

    ...

}

var a;

IEnumerator  e  =  GetList().GetEnumerator();

while (e.MoveNext)

{

    a = e.Current;

}

foreach 依赖 IEnumerable.

第一次 var a in GetList() 时 调用 GetEnumerator 返回第一个对象 并 赋给a,

以后每次再执行 var a in GetList() 的时候 调用 MoveNext.直到循环结束.

期间GetList()方法只执行一次.

for 循环靠下标定位.    list[3] 相当于 *(list + 3).

for(int i = 0; i < GetCount(); i++)

{

　　....

}

int i = 0;

while(i < GetCount())

{

　　...

}

for 循环每次循环会调用 GetCount() 来比较长度. 而 foreach 不考虑长度,只调用一次GetList().

结论.

在固定长度或长度不需要计算的时候for循环效率高于foreach.

在不确定长度,或计算长度有性能损耗的时候,用foreach比较方便.

ps:.首先增强for循环和iterator遍历的效果是一样的，也就说增强for循环的内部也就是调用iteratoer实现的，
1. 但是增强for循环有些缺点，例如foreach的时候会锁定集合中的对象.期间不能修改。不能获取下标等。 
2. ArrayList由于使用数组实现，因此下标明确，最好使用普通循环。 
3. 而对于LinkedList 由于获取一个元素，要从头开始向后找，因此建议使用增强for循环，也就是iterator。 
5、泛型

泛型，即“参数化类型”。

就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

一个简单的泛型类的定义：

public class GenericTest {

public static void main(String[] args) {

Box<String> name = new Box<String>("corn");
System.out.println("name:" + name.getData());
}
}
class Box<T> {

private T data;

public Box() {

}

public Box(T data) {
this.data = data;
}

public T getData() {
return data;
}
}

泛型解决了下面的问题：

List list = new ArrayList();
list.add("CSDN_SEU_Cavin");
list.add(100);
for (int i = 0; i < list.size(); i++) {
String name = (String) list.get(i); // 1  取出Integer时，运行时出现异常
System.out.println("name:" + name);
}

1.当我们将一个对象放入集合中，集合不会记住此对象的类型，当再次从集合中取出此对象时，改对象的编译类型变成了Object类型，但其运行时类型任然为其本身类型。

2.因此，1处取出集合元素时需要人为的强制类型转化到具体的目标类型，且很容易出现“java.lang.ClassCastException”异常。

public class GenericTest {

public static void main(String[] args) {

Box<String> name = new Box<String>("corn");
Box<Integer> age = new Box<Integer>(712);

System.out.println("name class:" + name.getClass());      // com.qqyumidi.Box
System.out.println("age class:" + age.getClass());        // com.qqyumidi.Box
System.out.println(name.getClass() == age.getClass());    // true
}
}

 

 ps：在使用泛型类时，虽然传入了不同的泛型实参，但并没有真正意义上生成不同的类型，传入不同泛型实参的泛型类在内存上只有一个，即还是原来的最基本的类型（本实例中为Box），

 当然，在逻辑上我们可以理解成多个不同的泛型类型。

究其原因，泛型只是作用于代码编译阶段，在编译过程中，对于正确检验泛型结果后，会将泛型的相关信息擦出，也就是说，成功编译过后的class文件中是不包含任何泛型信息的。泛型信息不会进入到运行时阶段。

对此总结成一句话：泛型类型在逻辑上看以看成是多个不同的类型，实际上都是相同的基本类型。

//基础的泛型测试
Collection<String> cc1 = new HashSet<String>();
cc1.add("aaa");
cc1.add("bbb");
cc1.add("ccc");
for(Iterator<String> it = cc1.iterator(); it.hasNext(); )
{
String ss1 = it.next();
System.out.println(ss1);
}

测试二：

public class ResponseVo<T> implements Serializable {
private String status;
private T data;

public T getData() {
return this.data;
}

public void setData(T data) {
this.data = data;
}
}

6文件的测试

            //文件的测试

           

int b = 0;
FileInputStream filein = null;
FileOutputStream fileout = null;
try{
filein = new FileInputStream("/Users/king/kong.c");
fileout = new FileOutputStream("/Users/king/kong1.c");
}catch(FileNotFoundException e)
{
System.out.println("open file error!");
System.exit(-1);
}
try{
long num = 0;
while((b = filein.read()) != -1){
System.out.print((char)b);
fileout.write(b);
num++;
}
filein.close();
fileout.close();
System.out.println("文件以复制");
System.out.println("共读取了"+ num +"字节");

}catch(IOException ex){
System.out.println("文件读取错误！");
}
FileWriter filew = null;
try {
filew = new FileWriter("/Users/king/unicode.txt");
for (int lan = 0; lan < 50000; lan++)
filew.write(lan);
filew.close();
}catch(IOException e){
e.printStackTrace();
System.out.println("文件读取错误");
System.exit(-1);

}

7、读写缓冲区的测试

//读写缓冲区的测试

try{
BufferedReader bread = new BufferedReader(new FileReader("/Users/king/kong2.c"));
BufferedWriter bwrite = new BufferedWriter(new FileWriter("/Users/king/kong2.c"));
String bs = null;
for( int i = 0 ; i< 100; i++)
{
bs = String.valueOf(Math.random());
bwrite.write(bs);
bwrite.newLine();
}
bwrite.flush();

while((bs = bread.readLine()) != null)
{
System.out.println(bs);
}
bwrite.close();
bread.close();
}catch (IOException io){
io.printStackTrace();
}

8、转换流 字符流 字节流 处理流 节点流

InputStreamReader isp = new InputStreamReader(System.in);
BufferedReader bfr = new BufferedReader(isp);
String sisp = null;
/*
try{
sisp = bfr.readLine();
while(sisp != null)
{
if(sisp.equalsIgnoreCase("exit"))
break;
System.out.println(sisp.toUpperCase());
sisp = bfr.readLine();
}
bfr.close();
}catch(IOException io)
{
io.printStackTrace();
} //阻塞的模式；
*/
//DataIo与ByteArryIO的测试
ByteArrayOutputStream baos = new ByteArrayOutputStream();
DataOutputStream dos = new DataOutputStream(baos);
try{
dos.writeDouble(Math.random());
dos.writeBoolean(true);
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
System.out.println(bais.available());
DataInputStream dis = new DataInputStream(bais);
System.out.println(dis.readDouble());
System.out.println(dis.readBoolean());
dos.close();
dis.close();
}catch(IOException io){
io.printStackTrace();

}9、print流

PrintStream pss = null;
try{
FileOutputStream fos = new FileOutputStream("/Users/king/print.dat");
pss = new PrintStream(fos);
}
catch (IOException io)
{
io.printStackTrace();
}
if(pss != null)
{
System.setOut(pss);
}
int ln = 0;
for(char cc2 = 0; cc2 < 10000; cc2++)
{
System.out.print(cc2+ " ");
if( ln++ > 100 )
{
System.out.println();
ln = 0;
}
}

对象流：

class ObjectTest{
int i = 10;
int j = 20;
transient int k = 30;

}

main：
//对象流的测试
try {
ObjectTest obt = new ObjectTest();
obt.i = 100;
FileOutputStream obts = new FileOutputStream("/Users/king/object.dat");
ObjectOutputStream objo = new ObjectOutputStream(obts);
objo.writeObject(obt);
objo.flush();

FileInputStream fiss = new FileInputStream("/Users/king/object.dat");
ObjectInputStream objis = new ObjectInputStream(fiss);

ObjectTest Tread = (ObjectTest)objis.readObject();

System.out.println("对象输出："+Tread.i + Tread.j + Tread.k);
}catch (IOException io)
{
io.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}

10、list的遍历方式
List遍历方式：
第一种：
for(Iterator iterator = list.iterator();iterator.hasNext();){
int i = (Integer) iterator.next();
System.out.println(i);
}
第二种：
Iterator iterator = list.iterator();
while(iterator.hasNext()){
int i = (Integer) iterator.next();
System.out.println(i);
}
第三种：增强的for循环
for (Object object : list) {
System.out.println(object);
}
第四种：
for(int i = 0 ;i<list.size();i++) {
int j= (Integer) list.get(i);
System.out.println(j);
}