java 从零开始，学习笔记之基础入门<数组列表（ArrayList）>（九）

数组列表（ArrayList）

数组列表（ArrayList）

是用来存储可变容量的数组，创建一个ArrayList对象默认的大小为10，如果我们往这个容器中放值，放入值的个数如果超过了默认值（指定的大小），ArrayList会自动的改变数组的长度存放值，不会出现数组下标越界异常

创建的一个ArrayList数组，如果没有给其指定类型，那么ArrayList数组可以用来存放所有类型的数据。

java.lang.Object

 java.util.AbstractCollection<E>

 java.util.AbstractList<E>

 java.util.ArrayList<E>

ArrayList 这个类是Object类的子类，ArrayList这个类是List接口的一个实现类

创建一个ArrayList对象的语法结构

ArrayList[<类型>] 对象名 = new ArrayList[<类型>]（）；

创建的对象如果没有指定类型可以存放所有类型，如果指定了类型，则只能存放指定类型的数据

package com.ibm.arraylist;

import java.util.ArrayList;

public class ArrayListDemo {

public static void main(String[] args) {

//创建一个ArrayList对象al

ArrayList al = new ArrayList();

al.add(12);

al.add("cw");

al.add(true);

al.add(new String());

//创建一个可变长的数组对象只能存放String类型

//ArrayList<String>表示是泛型用来规定可变长的数组中能存放数据的类型

//如果用泛型规定，那么其他类型的数据就不能放入到可变长的数组中去

ArrayList<String> als = new ArrayList<String>();

als.add("cw");

//als.add(14);

//als.add(false);

//als.add(new Date());

}

}

ArrayList常用方法：

package com.ibm.arraylist;

import java.util.ArrayList;

public class ArrayListDemo2 {

public static void main(String[] args) {

//创建两个ArrayList对象

ArrayList al1 = new ArrayList();//

al1.add(1);

al1.add(3);

al1.add(5);

al1.add(7);

al1.add(9);

ArrayList al2 = new ArrayList();//

al2.add(2);

al2.add(4);

al2.add(6);

al2.add(8);

al2.add(2);

System.out.println(al2.size()+"=========");

//

//boolean add(E e)

// 将指定的元素添加到此列表的尾部。

//void add(int index, E element)

// 将指定的元素插入此列表中的指定位置。

//boolean addAll(Collection<? extends E> c)

// 按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部。

//boolean addAll(int index, Collection<? extends E> c)

// 从指定的位置开始，将指定 collection 中的所有元素插入到此列表中。

//

// 在al2中的4后面加入一个数字5

al2.add(2,5);

al2.add(2,al1);//2 4 [1, 3, 5, 7, 9] 5 6 8

al2.addAll(al1);

System.out.println(al2.size());

for(int i=0 ; i<al2.size();i++){

System.out.print(al2.get(i)+" ");

}

//移除可变长数组中的所有元素

// al2.clear();

// System.out.println("_"+al2.size());

//clone方法

Object obj = al2.clone();

//将obj强制转换成ArrayList对象

ArrayList al3=(ArrayList)obj;

System.out.println(al3.size()+"<><><>");

//contains方法

boolean flag = al2.contains(8);

System.out.println(flag);

//indexof方法

int index=al2.indexOf(2);

System.out.println(index);

//isEmpty判断可变长的数组是否为空

boolean flag1 = al2.isEmpty();

System.out.println(flag1);

//remove方法

//移除al2中6这个元素值

al2.remove(2);//2代表的是6在al2中这个数组的索引

for(int i=0 ; i<al2.size();i++){

System.out.print(al2.get(i)+"---- ");

}

//要将int这个简单数据类型当做对象，那么就应该采用int类型的封装类封装成一个对象传递

boolean flag2 = al2.remove(new Integer(2));

System.out.println(flag2);

for(int i=0 ; i<al2.size();i++){

System.out.print(al2.get(i)+"---- ");

}

//removeRange方法是受保护的方法 只能在ArrayList这个类中使用

//set方法

al2.set(1,16);

System.out.println("\n");

for(int i=0 ; i<al2.size();i++){

System.out.print(al2.get(i)+"---- ");

}

//将a12这个可变长的数组转换成一个定长的数组

Object[] obj1 = al2.toArray();

for(int i=0;i<obj1.length;i++){

System.out.println(obj1[i]);

}

System.out.println("===========");

String str = "abcdefg";//aBcdefg

char[] cs = str.toCharArray();

String strs = "";

for(char s:cs){

if(s=='b'){

s='B';

}

strs +=String.valueOf(s);//将char的值转换成String类型

}

System.out.println(strs);

// System.out.println( str.toUpperCase());

}

}

通讯录：

采用可变长数组当做存储数据的容器，对这个对象进行操作

可变长的数组中存放的东西是联系人对象

1 注册

就是往可变长的数组中放入一个对象，注册几个就往其中放入多少个

2 登陆

就是判断你要登陆的用户和密码在可变长的数组存不存在那个对象，如果存在则让你登陆，不存在则不让你登陆

登陆成功之后才能看到 查看、删除、修改、注册功能

登陆不成功，则只能看到登陆、注册功能

3 查看

查看所有的联系人的信息（）

4 删除

根据id删除

5 修改

根据id修改

6 查找

根据id查找

类的继承：

子类继承父类，通过extends关键字来继承

语法: [<访问修饰符>]+class + 子类 extends 父类

继承之后,

* 子类就继承了父类中的非private修饰的属性或者方法

* 继承时所用的关键字是extends

* 构造器不能够被继承过来

* 所有类的父类都是object类

* 一个子类只能有一个父类，但是一个父类可以被多个子类所继承

* 从子类的角度看 子类 ——继承——》 父类

从父类的角度看 子类《——派生—— 父类

Java.lang.Object

继承的语法格式

访问修饰符 class 子类名 extends 父类名{

}

package com.ibm.extend.second;

publicclass Father { //父类

private String name;

publicvoid setName(String _name){

name = _name;

}

public String getName(){

returnname;

}

publicvoid show(){

System.out.println("我是父类的show方法");

}

publicvoid select(){

System.out.println("我是父类的select方法");

}

}

package com.ibm.extend.second;

publicclass Son extends Father {//继承父类

publicvoid pick(){

System.out.println("我是子类的pick方法！");

}

}

ToString方法：

在Object类中，定义了一个toString()方法，用于返回一个表示这个对象的字符串

覆盖该方法能用来提供某对象的自定义信息

* 在所有类的父类Object类，有一个ToString方法，这方法用于表示该类对象的字符串表示形式

* 如果将简单数据类型用封装类型表示，可以使用toString方法将该封装的对象转换成String型

Eg: Integeri=12;

正常情况下：

System.out.println(i+12); --》结果是 ：24

使用toString方法将i转换成String

System.out.println(i.toString()+12);à 结果是1212

* 覆盖toString方法可以自定义该对象的表示形式

父类：

Public classFather{

//父类覆盖了object类中的toString方法

@override

Public StringtoString(){

Return “这里你想怎么写就怎么写”;

}

}

返回回来的字符串，就是你自定义的该对象的表示形式

package com.ibm.extend.second;

public class Father {//父类

//将Object类中toString方法覆盖

public String toString(){

return"姓名："+name;

}

}

package com.ibm.extend.second;

public class Test {

public static void main(String[] args) {

//toString方法

Father f = new Father();

f.setName("cw");

System.out.println(f);

//采用toString方法将简单数据类型转换成String型

int m = 12;

String str = Integer.toString(m);

//将char转String

char c = 's';

String cs = Character.toString(c);

}

}

访问控制

访问控制的限制程度从高到低如下图所示。注意，Default不是一个修饰符，它只是用来表示一种不加任何修饰符时的状态。

访问范围： public > protecte > default >private

访问修饰符，可以修饰属性 、方法 、构造器

如果将构造器用private修饰，理论上可以，实际上也可以，但是如果你这样修饰，你这个类就没有必要存在

在同一个类中：

private String name;

protected String pass;

public String grade;

String num;

publicstaticvoid main(String[]args) {

VisitDemo vd=new VisitDemo();

//在当前类中，创建的对象可以调每个修饰符修饰的属性

}

创建的对象能够调到所有的属性

同一个包中不同的类中：

除了private修饰的属性外，其他的属性是可以都调到

同一个工程中，不同的包中：

子类继承了父类，那么在子类中创建子类的对象的时候，创建的对象只能调到public 和protected修饰的属性

在同一个工程中：

能够调到所有用public修饰的属性