List接口&及其子类ArrayList

System.out.print()方法默认调用了打印对象的toString（）方法。

toString()方法一般是要重写的

 

当一个父类有有参构造的时候，一定要有无参构造，因为子类继承的时候，会默认调用父类的无参构造，如果父类没有，那么编译器就会报错。

super指代的是直接父类

凡是继承，除了private 修饰的  和 构造方法，其他的都会有，即使不写，默认都会有。

size（）是集合中求元素个数的方法，等同于数组中的length（）

for（Object o:c）{

syso（o）;

}

 

迭代：就像普通for循环一样，i每次迭代数组中的元素，这就叫迭代。

迭代器Iterator  和增强for循环在集合遍历中的区别：

增强for循环在删除集合元素时可能会出错，而迭代器不会。

其余的没有什么太大的区别，只是迭代器是集合常用的遍历方法而已。

 

Math.PI  :   PI封装在Math类中，而且用static修饰，所以可以直接打点调用。

 

集合中存储基本数据类型，存储的都是包装类。

 

迭代器是接口，但是之所以可以创建对象，是利用它的子类来创建对象。

Iterator it =c.iterator（）；  it 是Iterator子类的对象。

 

在编译器中  将代码所有的类都写在一页，和分页写，只有访问修饰符不同的区别，其余没有区别。

利用编译期提供的重写equals方法时，可以选择要判断哪个属性，不一定都要判断，比如只判断name  就可以只打钩name，而不判断其他的属性。

迭代器是结合特有的遍历方法。

 

接口就是一个约定，规范，协议。

 

迭代器中的 hasNext()方法和 next（）方法要配对使用，负责可能出现空指针异常。  迭代器在集合中非常重要，要重点掌握。

 

List集合：有序可重复的集合

有序：插入顺序与存储顺序相同。

例如 ：

a.add(1);

a.add(9);

a.add(7);

打印出来的为 1，9，7  而不为  1,7,9  因为是插入顺序与存储顺序相同。

 

get()方法要重点掌握

 

DT时代：数据时代

 

泛型：将运行期异常转变为编译期异常

泛型:参数化类型。

<>中放入想存储的类型。

 

集合中使用了泛型的话，就只能 存储一种对象了，那样的话，数据和集合的区别就是：集合封装了方法，使用起来比较方便，数组没有封装方法，使用起来不方便，比如，要删除数组中的第二个元素，要写一个for循环，而要删除集合中的第二个元素，只要调用方法就好了。

在JAVA1.5版本以后， int类型与Integer类型的转换，是JAVA后台自动运行的，这叫自动装箱和自动拆箱。

 

集合中的常用方法：

remove (Object  o)  删除o对象

　　　　注意：默认任然调用equals方法来判断是否包含，对于自定义来说，必须得重写哈希方法和equals方法才可以使用。

代码示例：

public class  集合中常用方法 {
public static void main(String[] args) {
Collection c=new ArrayList<>();
// System.out.println(c);
//isEmpty  判断集合是否为空元素。
// System.out.println(c.isEmpty());
/*c.add(1);
c.add(2);
c.add(3);
c.add(4);
c.add(5);
System.out.println(c);
System.out.println(c.isEmpty());*/
Collection c1=new ArrayList<>();
c1.add(new P1("zs", 19));
c1.add(new P1("zs1", 19));
c1.add(new P1("zs2", 19));
c1.remove(new P1("zs", 19));
System.out.println(c1);
}
}
class P1{
String name;
int age;
public P1() {
super();
// TODO Auto-generated constructor stub
}
public P1(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "P1 [name=" + name + ", age=" + age + "]";
1
return "P1 [name=" + name + ", age=" + age + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
P1 other = (P1) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}

 

 

　　集合的遍历：

　　1.增强for循环

　　2.迭代器： Ieterator

　　　　　　　　hashNext()  判断是否有元素

　　　　　　　　next()  返回该位置的元素

代码示例：

public class  集合的遍历 {
public static void main(String[] args) {
Collection c=new ArrayList<>();// int a=5;
c.add(1);
c.add(2);
c.add(3);
c.add(4);
// System.out.println(c);
// 遍历集合
// 增强 for
/*for(Object o:c) {
System.out.println(o);
}*/
//***** 迭代器 ： Iterator -- 》集合的 iterator  获取到该接口
Iterator it=c.iterator();
/*System.out.println(it.hasNext());
System.out.println(it.next());
System.out.println(it.hasNext());
System.out.println(it.next());*/
while(it.hasNext()) {
Object o=it.next();
System.out.println(o);
}
}
}

 

List集合：

List集合中的常用方法：  

　　add(int index,E element)  在index索引位置，插入元素

　　get(index):通过index返回该索引位置的元素

　　set(int  index, E element)  设置index位置的元素为参数

 

代码示例：

public class List 集合接口 {
public static void main(String[] args) {
List list=new ArrayList<>();
list.add(1);
list.add(9);
list.add(7);
// System.out.println(list);
// add(int index, E element) 在 index 索引位置 插入元素。
// list.add(1, 2);
// get(index)  通过 index 返回该索引位置的元素
// System.out.println(list.get(2));
// 逆序遍历 其中，如果为逆序，则指针会上移，所以需要将指针置为长度位置。
/*ListIterator it = list.listIterator(list.size());
while(it.hasPrevious()) {
System.out.println(it.previous());
}*/
System.out.println(list);
//set(int index, E element) 设置 iindex 位置的元素为参数
list.set(1, 10);
System.out.println(list);
}
}

 

集合的泛型：

好处：将运行期的异常转换为编译期的异常

　　　类型可以转化

参数化类型，格式： <集合中存储的数据类型>

注意：尽管集合中可以存储任意类型的对象，但是一般需要加泛型，指定该集合只存储一种数据。

代码演示：

// 带有泛型的集合
ArrayList<Person> a=new ArrayList<>();
a.add(new Person(" 张三 ", 18));
a.add(new Person(" 李四 ", 18));
a.add(new Person(" 王五 ", 18));
a.add(new Person("maliu", 19));

 

集合的遍历：

代码示例：

List 集合的遍历 ：
*①  增强 for 循环
*②  迭代器 Iterator 接口
③ List 特有的迭代器接口 ： ListIterator
④ for 循环
代码演示：
// 带泛型的集合的遍历 迭代器也要加泛型。否则，数据类型为 Object
Iterator<Person> it= a.iterator();
while(it.hasNext()) {
System.out.println(it.next().name);
}