目录
包装类(Wrapped Class)
包装类的使用---装箱和拆箱
自动装箱和自动拆箱
Integer的易错题
javap反编译工具
List接口的使用
方法
ArrayList
使用
打印
区别
扩容机制
ArrayList练习
字符集合
杨辉三角
编辑
包装类(Wrapped Class)
Object 引用可以指向任意类型的对象,但有例外出现了, 8 种基本数据类型不是对象,那岂不是刚才的 泛型机制要 失效了?
实际上也确实如此,为了解决这个问题,java 引入了一类特殊的类,即这 8 种基本数据类型的包装类,在使用过程 中,会将类似 int 这样的值包装到一个对象中去。
包装类的使用---装箱和拆箱
int i = 10;
//显式
// 装箱操作,新建一个 Integer 类型对象,将 i 的值放入对象的某个属性中
Integer ii = Integer.valueOf(i);
Integer ij = new Integer(i);
// 拆箱操作,将 Integer 对象中的值取出,放到一个基本数据类型中
int j = ii.intValue();
自动装箱和自动拆箱
int i=10;
nteger ii = i; // 自动装箱
Integer ij = (Integer)i; // 自动装箱
int j = ii; // 自动拆箱
int k = (int)ii; // 自动拆箱
Integer的易错题
Integer a=127; Integer b=127; Sysyem.out.print(a==b);
答案:true
Integer a=128; Integer b=128; Sysyem.out.print(a==b);
javap反编译工具
javap-c(jdk 中一个反编译工具来查看下自动装箱和自动拆箱过程,并且看到这个过程是发生在编译期)
List接口的使用
方法
序列化:把一个对象转变为字符串
方法 :
boolean add(E e) 尾插 e
void add(int index, E element) 将 e 插入到 index 位置
boolean addAll(Collection<? extends E> c) 尾插 c 中的元素
E remove(int index) 删除 index 位置元素
boolean remove(Object o) 删除遇到的第一个 o
E get(int index) 获取下标 index 位置元素
E set(int index, E element) 将下标 index 位置元素设置为 element
void clear() 清空
boolean contains(Object o) 判断 o 是否在线性表中
int indexOf(Object o) 返回第一个 o 所在下标
int lastIndexOf(Object o) 返回最后一个 o 的下标
List<E> subList(int fromIndex, int toIndex) 截取部分 list
方法
ArrayList() 无参构造
ArrayList(Collection<? extends E> c) 利用其他 Collection 构建 ArrayList
ArrayList(int initialCapacity) 指定顺序表初始容量
ArrayList
使用
boolean add(E e) 尾插 e
void add(int index, E element) 将 e 插入到 index 位置
boolean addAll(Collection<? extends E> c) 尾插 c 中的元素
E remove(int index) 删除 index 位置元素
boolean remove(Object o) 删除遇到的第一个 o
E get(int index) 获取下标 index 位置元素
E set(int index, E element) 将下标 index 位置元素设置为 element
void clear() 清空
boolean contains(Object o) 判断 o 是否在线性表中
int indexOf(Object o) 返回第一个 o 所在下标
int lastIndexOf(Object o)
打印
五种方法
List<Integer> list1=new ArrayList<>(10);
List<String> list2=new ArrayList<>();
ArrayList<String> list3=new ArrayList<>();
list2.add("It");
list2.add("was love ");
list2.add("at first sight.");
//关于打印
System.out.println(list2);
System.out.println("------------------");
for (int i = 0; i < list2.size(); i++) {
System.out.print(list2.get(i)+" ");
}
System.out.println();
System.out.println("------------------");
for(String s:list2){
System.out.print(s+" ");
}
System.out.println("--使用迭代器打印--");
Iterator<String> it=list2.iterator();
while(it.hasNext()){//判断后面是否还有元素
System.out.print(it.next()+" ");//
}
System.out.println("--迭代器List相关打印");
ListIterator<String> it2=list2.listIterator();
while(it2.hasNext()){
System.out.print(it2.next()+" ");
}
/**
* 使用迭代删除(Iterator.remove()),可能会因为没有it.next()抛出并发修改异常(,
* 先迭代元素再删除,避免对同一个迭代器remove多次而异常
* ArrayList不是线程安全的
* ***/
区别
List<String> list1=new ArrayList<>(); ArrayList<String> list2=new ArrayList<>();
list1的方法比list2少,因为list1由父类List调用,就只能调用List接口的方法。除非子类重写了父类的方法。
扩容机制
ArrayList是一个动态的扩容机制,在插入元素过程中会自动扩容。
List<Integer> list = new ArrayList<>(); for (int i = 0; i < 100; i++) { list.add(i); } //既然没给初始值,就不会存在越界问题吗?
- 检测是否需要扩容,如果是调用grow准备扩容;
- 预估需要库容的大小
- 初步预估按照1.5倍进行扩容;
- 如果用户所需要的大小超过预估1.5倍左右,则按照用户所需大小进行扩容;
- 真正扩容之前检测是否能扩容成功,防止太大导致扩容失败;
- 使用copyOf进行扩容;
如果ArrayList调用不带参数的构造方法,那麽顺序表的大小是0,第一次add的时候,整个顺序表才变成了10;当这个10放满了,以1.5倍扩容;
如果调用的是给定容量的构造方法,那麽顺序表的大小就是你给定的容量,放慢了就仍然以1.5倍进行扩容;
ArrayList练习
1. 学生对象放在List中,每个学生有一个姓名,班级,考试成绩属性(double)次考试结束后,每个学生都获得了一个考试成绩,遍历list集合,并把学生对象的属性打印出来;
2.有一个List中存放整形元素,要求使用Collections.sort对他们排序
class Student{
private String name;
private String classes;
private double score;
public Student(String name, String classes, double score) {
this.name = name;
this.classes = classes;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getClasses() {
return classes;
}
public void setClasses(String classes) {
this.classes = classes;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", classes='" + classes + '\'' +
", score=" + score +
'}';
}
}
public class TestDemo {
public static void main2(String[] args) {
ArrayList<Integer> integers=new ArrayList<>();
integers.add(33);
integers.add(11);
integers.add(22);
Collections.sort(integers);//Collections是一个类进行升序
System.out.println(integers);
}
public static void main1(String[] args) {
//<>中可以放自定义类型
ArrayList<Student> students=new ArrayList<>();
students.add(new Student("小明","102",99));
students.add(new Student("小美","102",99.7));
System.out.println(students);
}
}
sum:
* Collection是接口,继承他的接口的主要是List接口,Set接口,Queue接口
* Collections是类,提供了集合相关操作的静态方法类,eg:Collections.reverse(list).
* ArrayList可以在<>中放自定义类型;
* *
3.删除第一个字符串中出现的第二个字符串中的字符。使用ArrayList解决
eg:
String str1="welcome to";
String str2="come";
输出结果:wl t public static void main(String[] args) {
String str1 = "welcome to";
String str2 = "come";
ArrayList<Character> list = new ArrayList<>();
for (int i = 0; i < str1.length(); i++) {
char ch = str1.charAt(i);
if(!str2.contains(ch+"")){
list.add(ch);
}
}
//这样直接打印list的话打印的数组类型,so
for(char ch:list){
System.out.print(ch);
}
}
sum:
String中的contains方法(返回boolean类型,源码重写了equal方法):A.contains(B),判断A字符串中是否包含字符串B
public static void main(String[] args) { String str1="hello"; String str2="eo"; System.out.println(str1.contains(str2)); } 输出false
字符集合
public class TestDemo {
//a-97,A-65
public static String func1(String str){
StringBuilder sb=new StringBuilder();
int[] array=new int[124];
for (int i = 0; i < str.length(); i++) {
char ch=str.charAt(i);
if(array[ch]==0){
sb.append(ch);
array[ch]=0;
}
}
return sb.toString();
}
public static String func(String str){
StringBuilder sb=new StringBuilder();
for(int i = 0;i< str.length();i++){
char ch = str.charAt(i);
if(!sb.toString().contains(ch+"")){
sb.append(ch);
}
}
return sb.toString();
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while(scanner.hasNextLine()){
String str=scanner.nextLine();
String ret=func(str);
System.out.println(ret);
}
}
}
杨辉三角
class Solution {
public List<List<Integer>> generate(int numRows) {
List<List<Integer>> ret=new ArrayList<>();
//第一行
List<Integer> list1=new ArrayList<>();
list1.add(1);
ret.add(list1);//把第一行数据放在List中
for(int i=1;i<numRows;i++){
List<Integer> list=new ArrayList<>();
list.add(1);//每一行开始都是1
List<Integer> preRow=ret.get(i-1);//上一行
for(int j=1;j<i;j++){
int num1=preRow.get(j)+preRow.get(j-1);
list.add(num1);
}
list.add(1);
ret.add(list);
}
return ret;
}
}