1.Collection常见的方法实例
指定集合类中放哪些元素的时候,一定要指定类型,<>里面不要用简单类型
Collection<Integer> collection=new ArrayList<>();
//1添加某些元素
collection.add(1);
collection.add(2);
collection.add(3);
//2删除某个元素
collection.remove(1);//注意这里面的clear是针对集合类里面的元素全部进行清空
//3打印集合类里面的元素
System.out.println(collection);//打印结果是2,3
//4把集合类中的所有元素放到数组中
Object[] arr1= collection.toArray();
//5判断是否为空
System.out.println(collection.isEmpty());
//6获取到集合类里面的长度
System.out.println(collection.size());
Map<String,String> map=new HashMap<>();
map.put("及时雨","宋江");
map.put("国民女神","高圆圆");
Set<Map.Entry<String,String>> set=map.entrySet();
//1)当我们调用这个方法之后,会把哈希表中的每一对key和value包装成一个整体,相当于把两个元素放到一个大盒子里面,变成一个元素
//2)然后内存就会把每一个大盒子放到Set里面,这个大盒子就是Map.Entry(String,String)类型
for(Map.Entry<String,String> sb:set)
{
System.out.println(sb.getKey());
System.out.println(sb.getValue());
}
2.简单类型和包装类(针对的是基本数据类型)
1)将简单的数据也是可以面向对象的,让整数与字符串之间的转换更加方便,只需要调用一个方法即可,就不需要自己写一个方法来进行实现
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
我们在对数据类型进行转换的时候
//1将字符串转化成整数
String str="123";
int a=Integer.valueOf(str);
int b=Integer.parseInt(str);
//2将整数转化成字符串
String str1=Integer.toString(a);
int与Integer的区别
1)类型不同:Integer是对象类型,int是基本数据类型,Integer是int的包装类
2)Integer的默认值是null,int的默认值是0,当new Integer()的时候实际上是生成一个指针指向对象,但是int直接储存数值;
3)Integer变量需要实例化之后才能使用,int则不需要。
4)Integer变量和int变量进行比较时,java会自动将Integer对象拆包装为int,然后进行比较,实际上就变为两个int变量比较。
5)Integer实际是对象的引用,指向此new的Integer对象;int是直接存储数据值
6)包装类型可以用于泛型,但是简单类型是不可以的
2)装箱和拆箱
装箱/装包:将一个简单的数据类型转化成包装类型
拆箱/拆包:将一个包装类型转化成简单的数据类型
下面是隐式的进行装包和拆包
1)Integer a=123;//123本来是一个简单数据类型,但是最终变成了包装类,这个过程就是装箱
上面的过程中底层默认调用了Integer.valueOf()方法
2)int b=a;//a本来是一个包装类,就将一个包装类型转化成简单的数据类型,拆箱
他的底层默认调用了intValue()方法
Integer a=10;
System.out.println(a.value);
这会访问失败,因为value字段是默认是Integer包装类中的用private修饰的字段,所以说简单数据类型在包装类中就是一个Value属性
下面是显示进行装包和拆包
//显示进行装包
Integer integer=new Integer(123);
Integer s1=Integer.valueOf(123);
//显示进行拆包
int a=s1.intValue();
double b=s1.doubleValue();
Integer a=123;
Integer b=123;
System.out.println(a==b);//true
Integer c=129;
Integer d=129;
System.out.println(c==d);//false
public static Integer valueOf(int i)
{ if(i>IntegerCache.low&&i<=IntegerCache.high)(low=-128,high=127)
return Integer.Cache[i+(-IntegerCache.low)](注意,这里面的Cache是一个数组)
return new Integer(i);
}
当我们传入127的时候,返回的是Cache[255],此时128是最大的数据,此时得到的数组下标就是255;当我们传入-128的时候,返回的是Cache[0],
注意这个数组里面的范围下标是0-255;
Cache[0]=-128; Cache[1]=-127;.........Cache[255]=127
总结:当我们传入的数据在-128-127内,会先进行计算下标,再会返回数组里面所存放的值;返回的是数值;
掏出了这个数据范围之后,就会在堆上new 一个新的对象,返回的是一个对象,此时我们要进行比较的是引用;
3.泛型
下面是一个简单的顺序表,我们在这里面实现的一个顺序表,是存放的数据类型只有int类型,这就会很不通用,如果我们想什么样的类型的数据都想要放进去,就要把这个数组的类型设置成Object类型
class MyArraylist{
private int[] arr1;
private int usedsize;
public MyArraylist()
{
this.arr1=new int[10];
}
public void add(int pos,int val)
{
this.arr1[pos]=val;
}
public int get(int pos)
{
return this.arr1[pos];
}
}
改成下面的代码之后,还是发现有问题:1)这个代码太通用了,什么样类型的数据都可以进行存放不能指定元素;
2)取出我们的顺序表中的元素,还需要进行强制类型转换,这是很麻烦的;
我们现在想要做到下面几件事:1)能不能指定我这个顺序表的类型
2)指定类型之后,是不是就只能存放指定类型的数据呢?
3)取出数据之后,可不可以不进行数据类型转换?
static class MyArraylist{
private Object[] arr1;
private int usedsize;
public MyArraylist()
{
this.arr1=new Object[10];
}
public void add(Object val)
{
this.arr1[usedsize]=val;
usedsize++;
}
public Object get(int pos)
{
return this.arr1[pos];
}
}
public static void main(String[] args) {
MyArraylist list=new MyArraylist();
list.add(1);
list.add("hello");
String ret=(String)list.get(1);
}
在指定类的后面写上<T>,它是代表当前的类是一个泛型类,此时的这个T就只是一个占位符而已,把类型参数化了,不能泛型化数组;
泛型的意义:1)存放数据的时候,会自动地对要放进去的类型进行检查,当取数据的时候,会自动地对取出来的数据进行强制类型转换
2)泛型中<>里面的内容是不进行参与类型的组成的
3)泛型类型的参数,只能是包装类,而不能是简单类型
泛型是怎么进行编译的?
反省是编译时期的一种机制
泛型这个概念只在编译时期起作用,在运行时期是没有泛型这个概念的;在编译时会被擦除为Object类型