输出语句直接输出一个对象 默认调用了该对象的tostring方法
对象数组:
数组既可以存基本类型 也可以存引用类型.
存基本类型存值 存引用类型存地址值
Student[] arr = new Student[5]; 引用数组
arr[0] = new Student["李四",23];
arr[0] = new Student["张三",23];
arr[0] = new Student["剑魔",23];
for (int i = 0 ; i <arr lanegth; i++)
System.out.println(arr[i])
集合框架:
集合的由来: 所谓的集合开发
数组长度是固定的.当添加的元素超过了数组的长度时需要对数组的重新定义 太麻烦
java内给我们提供了集合类. 能储存任意对象,长度是可以改变的 随着元素的增加而增加,随着元素的键少而键少
数组和集合的区别:
数组既可以存储基本数据类型 又可以存储引用数据类型.基本数据类型存储的是值 引用数据类型存储的地址值
集合只能存储引用数据类型对象, 集合中也可以存储基本数据类型,但在存储的时候会自动装箱对象100
区别2:
数组长度是固定的, 不能自动增长
集合长度是可以改变的.可以根据元素的增加而增长
数组和集合什么时候用:
如果元素个数是固定的推荐用数组
如果元素个数不是固定的,推荐用集合
集合继承体系图:
单列集合:以截图,
顶层接口:Collection
Collection方法名:
add方法如果是List集合一直都返回true, 因为list集合中可以存储重复元素
ArrayList的父类的父类重写toString 方法,所以打印对象引用
Collection c = new ArrayList(); // 父类引用指向子类对象
boolean b1 = c.add("abc");
boolean b2 = c.add("true"); // 自动装箱
boolean b3 = c.add(1oo);
boolean b4 = c.add(new Student("张三",23));
boolean b5 = c.add("abc");
System.out.println(b1);
System.out.println(b2);
System.out.println(b3);
System.out.println(b4);
System.out.println(b5);
System.out.println(c);
Collection c = new ArrayList();
c.add("a");
c.add("b");
c.add("c");
c.add("d");
c.remove("b") // 删除
c.clear(); //清空集合
System.out.println(c.contains("b"));
System.out.println(c.Empry()); //是否为空
System.out.println(c.size()); //获取集合的长度
System.out.println(c)
面试题:如何获取字符串.数组. 集合的长度
字符串:length()
数组:length
集合的长度:size()
集合的遍历方式:
其实就是一次获取集合中的每一个元素
Collection c = new ArrayList();
c.add("a");
c.add("b");
c.add("c");
c.add("d");
Object[] arr = c.toArray();// 集合转换成数组
for(int i = 0 ; i < arr.length; i++)
System.out.println(arr[i]);
自定义对象:
集合转换数组: public Object[] toArray();
Collection c = new ArrayList();
c.add(new Student("张三",23));
c.add(new Student("啊啊",88));
c.add(new Student("是是是",66));
c.add(new Student("在画图试试",22));
Object[] arr = c.toArray();
for(int i = 0 ; i < arr.length; i++)
System.out.println(arr[i]);
Satudent s = (Student)arr[i]; (乡下转型)
System.out.println(s.getName()+"..."getAge());
第二题:新建一个学生类.然后在测试类中创建一个集合 里边存3个煞笔
带addAll的方法
Collection c1 = new ArrayList();
c1.add("a");
c1.add("b");
c1.add("c");
c1.add("d");
c1.add("e");
Collection c1 = new ArrayList();
c2.add("a");
c2.add("b");
c2.add("c");
c2.add("d");
c2.add("e");
c1.addAll(c2);// 把c2中的所有元素添加到集合 才
中
c1.add(c2);
System.out.println(c1)
removeAll:
Collection c3 = new ArrayList();
c3.add("a");
c3.add("b");
c3.add("c");
c3.add("d");
c3.add("e");
c2.add("z");
boolean b = c1.removeAll(c2);
System.out.println(b);
System.out.println(c1);
containsAll:
Collection c1 = new ArrayList();
c1.add("a");
c1.add("b");
c1.add("c");
c1.add("d");
c1.add("e");
Collection c2 = new ArrayList();
c2.add("a");
c2.add("b");
c2.add("z");
boolean b = c1.containsAll(c2);
System.out.println(b);
retainAll:
Collection c1 = new ArrayList()
c1.add("a");
c1.add("b");
c1.add("c");
c1.add("d");
c1.add("e");
Collection c2 = new ArrayList()
c2.add("d");
c2.add("e");
c2.add("z");
boolean b = c1.retainAll(c2)
System.out.println(b);
System.out.println(c1);
通过迭带器:
集合是用来存储元素. 存储的元素需要查看. 那么需要迭代. 遍历
Collection c = new ArrayList();
c.add("a");
c.add("b");
c.add("c");
c.add("d");
麻烦的方法:
Iterator it = c.iterator();
boolean b1 = it.hasNext();
Object obj1 = it.next();
System.out.println(b1);
System.out.println(obj1);
boolean b2 = it.hasNext(); // 判断集合中是否有元素
Object obj2 = it.next();
System.out.println(b2);
System.out.println(obj2);
高大尚的方法:
1,通过集合对象获取对应的,迭代骑对象
iterator();
2,判断迭代骑中是否有元素
hasNext();
3,有就获取
next();
Iterator it = c.iterator();
while(it.hasNext())
System.out.println(it.next())
Collection c = new ArrayList();
c.add(new Student("啊啊啊",23));
c.add(new Student("张散",21));
c.add(new Student("啊啊啊",42));
c.add(new Student("画图试试",3123));
Iterator it = c.iterator()
while(it.hasNext())
Student s = (Student)it.next();
System.out.println(it.next());
System.out.println(s.getName() + ".." +S.getAge());
迭代骑的原理:
迭代骑是用来对集合进行遍历的. 但是我们知道每一种集合内部的数据结构都是不一样的
进而导致(集合)存取元素的方式也是不一样的如果我们把hasNext()和next()方法都定义到每个集合类中
整个集合体系就显得冗余所以不段向上抽取 最终抽取出一个Iterator接口.让集合类来实现这个接口就可以
重点!
list体系: 有序,. 元素的存取 顺序是一致的.可重复
List 体系的特有方法:
void add(int index, object obj);
Object remove(int index);
Object get(int index) ;
Object set(int index , Object obj)
注意:
index的反悔不能超过. 集合的长度 或者会爆错;
remove() 进行删除操作的时候不会自动装箱, 也就是说我们传的整数会直接被识别为索引
List list = new ArrayList()
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add(4,"f"); //index<=size
System.out.println(list);
List list = new ArrayList()
list.add("a");
list.add("b");
list.add("c");
list.add("d");
Object obj = list.remove(1);
System.out.println(obj);
System.out.println(list);
List list = new ArrayList()
list.add("111");
list.add("222");
list.add("333");
list.add("444");
list.remove(111); //删除的时候不会自动装箱. 把111当作索引
System.out.println(list);
List list = new ArrayList()
list.add("a");
list.add("b");
list.add("c");
list.add("d");
Object obj1 = list.get(1);
System.out.println(obj1)
//通过索引遍历list集合
for(int i = 0; i < list.size() ;i++)
System.out.println(list.get(i));
List集合独有的遍历方式
get方法和Size方法结合使用
List list = new ArrayList()
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.set(1,"z");
System.out.println(list.set(1,"z"));
System.out.println(list);
病发修改异常: concurrentModificationException
产生原因: 通过普通的迭代器遍历集合的时候 又同时往集合中添加元素
解决方案:通过列表迭代骑ListIterator 来遍历集合,并且通过 列表迭代骑add()方法网集合添加元素
列表迭代骑ListIterator:
正向遍历:从前往后拿元素
boolean hasNext();
Object next();
逆向遍历:从后往前拿元素
boolean hasPrevious();
Object nextPrevious();
注意: 进行逆向遍历之前, 必须先对集合进行正向遍历.否则打印结果是空
"a","b","c","d",
List list = new ArrayList()
list.add("a");
list.add("b");
list.add("world");
list.add("b");
list.add("c");
ListIterator lit = list.listIterator();
while(lit.hasNext()) {
System.out.println(lit.next());
System.out.println("__________________________");
while(lit.hasprevious())
System.out.println(lit.previous);
}
vector: 现在基本不用了.
被ArrayList替代了
addElement();添加元素
elementAt(); 获取索引获取元素
public Enumeration element(); 获取集合中所有的元素
Enumeration 中的两个方法:
hasMoreElements(); 判断是否有下一个元素 根hasNext(作用一样)
nextElement(); 获取下一个元素.跟现在的next方法作用一样
Vector v = new Vector();
v.addElement("a");
v.addElement("b");
v.addElement("c");
v.addElement("d");
Enumeration en = v.elements();
while(en.hasMoreElements()) {
System.out.println(en.Element());
}
数据结构之 数组 和链表:
数组: 查询快修改快.增删慢
里边的每个元素都有编号(索引,)并且编号是从0开始的
链表: 查询慢修改慢, 增删快.
LinkedList:链表 查询修改慢 增删快现成不安全.不同步 效率高
查询修改慢
增删快
现成不安全.不同步 效率高
Arraylist: 数组 查询快修改快 增删慢 现成不安全 同步效率高
查询快修改快
增删慢
现成不安全.同步 效率高
重点面试必考
List的三个儿子 我们怎么选择什么时候用谁?
查询多用ArrayList,
增删多用,LinkedList
如果都多.或者需求不明确, 用ArrayList 最常用的就是ArrayList
set体系:无序 元素的存取顺序是不一致的 不可重复
Hashset:
TreeSet:
双列集合:
HashMap:
TreeMap:
学顶层,用底层. |
收藏
淘帖
踩
