学java 第13天 集合ArrayList

1.介绍了三个方法并进行了重写【覆盖】toString(); equals();

一.toString()

String和Student都是引用数据类型看下面输出对比

import java.math.*;
public class Exec2{
	public static void main(String[] args){
		/*Teacher t1=new Teacher("张三",18,new BigDecimal(999999),'男');
		Teacher t2=new Teacher("李四",18,new BigDecimal(5000),'男');
		Teacher t3=new Teacher("张三",18,new BigDecimal(999999),'男');
		System.out.println(t1.equals(t2));
		System.out.println(t1.equals(t3));
		System.out.println(t1);*/
		String s1=new String("第一帅");

		Student ss=new Student();
		ss.name="第二帅";
		System.out.println(s1);
		System.out.println(ss);

	}
}
class Student{
	String name;

}

一个是字符串的内容，一个却是地址；

解释：Object是最大的父类，即鼻祖类，当对对象输出的时候默认为 对象.toString();方法 看Object类中的toString()方法

  public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

这个方法返回的是类名+@+地址，所以String不满足Object类的方法进行了方法重写后即

public String toString() {
        return this;
    }

所以Student也要进行重写一下即

class Student{
	String name;

	@Override
	public String toString(){
		return name;
	}
}

 

二.equals()

两个对象xxx属性一样的时候  将两个对象视为相等对象

如果想要将两个对象视为相等对象

底层需要调用equals方法

Equals是直接继承自Object中，底层默认比较地址

如果我们想要比较两个对象的属性，需要覆盖equals()

和toString()原理一样 找出Object类的equals() 方法

public boolean equals(Object obj){

    return this==obj;
}

显然进行重写 要注意三部分 obj为空怎么处理，obj不是这个类怎么处理，调用者自己和自己比泽呢么处理呢  对Teacher类进行equals（）方法重写 如下

	@Override
	public boolean equals(Object obj){
		//Teacher t2=(Teacher)obj;
		//1.解决空指针异常 健壮性
		if(obj==null) return false;

		//2.解决类型不匹配
		if(!(obj instanceof Teacher)) return false;

		//3.解决与自己比较 快速
		if(this==obj) return true;

		/*this.name.equals(t2.name)
		this.age==t2.age;
		this.salary.compareTo(t2.salary())==0;
		this.gender==t2.gender;*/


		return (this.name.equals(((Teacher)obj).name)&&this.age==((Teacher)obj).age&&
		this.salary.equals(((Teacher)obj).salary)&&this.gender==(((Teacher)obj).gender));
	}

三.hashCode()

官方规定如果equals进行了方法覆盖【重写】 那么对应的hashCode ()方法也要进行重写。

hashCode():制定一个对象的散列特征码

散列特征码？哈希码值

散列？将一堆元素分散到不同的小组

哈希码值怎么制定？

引用数据类型对象.hashCode()+基本数据类型;

public native int hashCode()

	@Override
	public int hashCode(){
		//引用数据类型就是 .hashCode()+
		//基本数据类型 +
		return name.hashCode()+age+salary.hashCode()+gender;
	}

以上三个方法的练习

public class Exec3{
	public static void main(String[] args){
		Computer c1=new Computer("惠普",100,'红',5865,true);
		Computer c2=new Computer("联想",250,'绿',8666,false);
		Computer c3=new Computer("惠普",100,'红',5865,true);

		System.out.println(c1);
		System.out.println(c2);
		System.out.println(c3);
		System.out.println(c1.equals(c2));
		System.out.println(c1.equals(c3));
		System.out.println(c1.hashCode()==c2.hashCode());
		System.out.println(c1.hashCode()==c3.hashCode());
	}
}
// 打印电脑对象的时候 显示
// XXX牌子的电脑新出来一款YYY颜色 尺寸是ZZZ 售价YY元
// 至今还没有上市/已经上市 StringBuffer的append()

// 如果两个电脑所有属性一样视为相等对象

// 如果两个对象视为相等对象 哈希码值应该一样
class Computer{
	String name;
	double size;
	char color;
	int price;
	boolean isShangShi;

	public Computer(String name, double size, char color, int price, boolean isShangShi){
		this.name = name;
		this.size = size;
		this.color = color;
		this.price = price;
		this.isShangShi = isShangShi;
	}
	@Override
	public String toString(){
		StringBuffer sb=new StringBuffer("");
		sb.append(name);
		sb.append("牌子的电脑新出来一款");
		sb.append(color);
		sb.append("颜色 尺寸是");
		sb.append(size);
		sb.append("售价");
		sb.append(price);
		sb.append("元");
		sb.append((isShangShi?" 已经上市":" 未上市"));

		return sb.toString();
	}
	@Override
	public boolean equals(Object obj){
		if(obj==null) return false;
		if( !(obj instanceof Computer)) return false;
		if(this==obj) return true;

		Computer c1=(Computer)obj;

		return this.name==c1.name&&
			   this.color==c1.color&&
			   this.price==c1.price&&
			   this.size==c1.size&&
			   this.isShangShi==c1.isShangShi;
	}

	@Override
	public int hashCode(){
		int shangShi=isShangShi?1:0;

		return name.hashCode()+(int)size+color+price+shangShi;

	}

}

 

四.集合

集合和数组什么区别

集合：容器 存放元素 创建的时候无需指明大小 可以存放无数个元素【富有弹性】

数组：容器 存放元素 数组在创建的时候要指明数组的大小 一旦元素超越数组大小 需要利用数组复制 手动扩容

java中 JCF【java collection framework】

     coolection[单值集合]                          Map[键值对集合]

        List                Set                              SortedMap

        [有序]              [无序]

      【不唯一】     【唯一】                        

                               SortedSet

                                [有序]

                                [唯一】

 

什么是单值集合：

                一次集合中存放一个元素

什么是键值对集合：

                一次往集合中添加一对元素[key键=value值]\

Set List Map是同一层级吗？

                List和Set 是 Collection的子接口

                Collection和Map是同一层级

List 

List 有序 不唯一【以下是LIst的实现类】

ArrayList

Vector

LinkedList

Stack

包装类 

作用

由于集合的只能存放Object类型的数据 不能直接存放基本数据类型的数据 为了集合中也可以存储基本数据类型 采取包装类

借助包装类可以完成String到基本数据类型的转换

没有parseChar 对于String=>char 需要借助String中的charAt(下标) 的方法  

		// String => 基本数据类型  借助包装类
		// "45" => 45
		// String => int
		String s1 = "45";//
		// 一旦s1不是整数 NumberFormatException
		int x = Integer.parseInt(s1);

		String s2 = "45.5";
		double d = Double.parseDouble(s2);

		System.out.println(d);


		// parseChar()
		// String => char
		// String => 校验["男"/"女"] => char
		String str = "男";
		char c1 = str.charAt(0);
		System.out.println(c1);

基本数据类型=》包装类 封箱/打包

        int x = 45;

		// jdk5.0之后
		Integer xx = x;

包装类=>基本数据类型 拆箱/解包

    Integer yy = new Integer(100);

		// jdk5.0之后
		int y = yy;// 自动拆箱/解包

boolean char byte short int long float double

Boolean Character Byte Short Integer Long Float Double

 Integer缓存数据 [-128-127] 

		// 如果不在[-128 127] 按照new的方式理解
		// 地址肯定不一样
		Integer x = 45;
		Integer y = 45;
		System.out.println(x == y);// 地址 true

		Integer xx = -128;
		Integer yy = -128;
		System.out.println(xx == yy);// 地址 true


		Integer xxx = 127;
		Integer yyy = 127;
		System.out.println(xxx == yyy);// 地址 true

		Integer a = 666;// new
		Integer b = 666;// new
		System.out.println(a == b);// 地址 false

ArrayList

 特点：有序 不唯一

数据结构：Object[]

一般用法：

创建一个Integer的ArrayList

ArrayList<Integer> list = new ArrayList<>();

1.添加元素 add();

		// 一次添加一个元素
		list.add(45);
		list.add(100);
		System.out.println(list);// [45, 100]

        面试题：Collection和Collections的区别？
        // Collection是单值集合的父接口
        // Collections 是集合的工具类

2. 一次添加多个元素 Collections.addAll();

Collections.addAll(list,23,45,100,99,200);

3.在索引位置插入数据 add(index,data);

	    list.add(6, 666);
		list.add(list.size(), 666);// list.add(666); 追加

4 修改元素 set(int index, 元素)

		// list.set(list.size(), 888);
		list.set(list.size()-1, 888);
		System.out.println(list);

5.返回指定位置上的元素get(int index) [0-list.size()-1]

		// 返回指定位置上的元素
		Integer x = list.get(0);
		System.out.println(x);

6. indexOf(元素) / lastIndexOf(元素)

		// 返回此列表中首次出现的指定元素的索引
		int index = list.indexOf(45);
		int index2 = list.lastIndexOf(45);

7.contains(元素) true-元素个数>=1/false-0个

		boolean flag = list.contains(45);
		System.out.println(flag);

8.清空集合内容 clear()

		// list.clear();
		System.out.println(list);// []

9. 判断集合是否是空 isEmpty();

		boolean ff = list.isEmpty();// list.size()==0
		System.out.println(ff);

10.toArray()  将内容转化成类型的数组

		Integer[] data = new Integer[list.size()];
		data = list.toArray(data);

		// Integer[] data = list.toArray(new Integer[0]);
		Integer[] data = list.toArray(new Integer[list.size()]);
		System.out.println(Arrays.toString(data));

遍历可有 for+i 或者 foreach