权限修饰符和集合

1权限修饰符

权限： 针对于类，属性， 方法 在使用他们的时候是有权限的。

public private 默认的 （啥也不写） protected

修饰类 ， 属性， 方法 等

1.1private

修饰方法和属性

私有化的所有的方法和属性只能在本类中使用，

1.2默认的

修饰方法和属性

1. 同一个类可以访问

2. 同一个包下面的类可以使用

3. 不同包的子类和其他类不能使用

1.3 protected

修饰属性和方法

1. 同一个类可以使用

2. 同一个包下面的不同类可以使用

3. 不同包下面的子类可以使用

4. 不同包下面的类不能使用

1.4public

只要在一个项目中就可以使用

本类、同一个包下面的不同类、不同包下面的类都可以使用

权限修饰符	当前类	同一个包下面的其他类	其他包下面的子类	其他包其他类
public	可以	可以	可以	可以
protected	可以	可以	可以	不可以
默认的	可以	可以	不可以	不可以
private	可以	不可以	不可以	不可以

2.集合

2.1集合结构

interface Collection<E> Java中的集合总接口

List<E> Collection的子接口，特征：存放的数据是有序的，可以重复

ArrayList<E>是 List 的实现类，实现List接口所有的抽象方法，底层是数组

ListedList<E> List的实现类，里面有独有的方法，底层是链表

Set<E>Collection的子接口，里面有自己独特的方法 底层是链表

HashSet<E> Set的实现类，底层是Hash算法

TreeSet<E> Set的实现类，底层是二叉数

 

2.3Collection接口

Collection下面的方法：
    增:
    boolean add(E e);  添加数据的
    boolean addAll(Collection<? extends E> c);  将一个集合添加到另外的一个集合中
    删：
    boolean remove(Object obj); 删除指定的元素
    boolean removeAll(Collection<?> c)删除指定集合中包含的所有此集合的元素（可选操作）
    void clear();  清空集合中所有的元素
    
 查:
    int size();  集合中元素的个数
    Object[]  toArray();将集合转为数组
    
 boolean contains(Object obj);在集合中是否包含一个obj元素
 boolean containsAll(Collection<? extends E> c); 判断一个集合是否是另外一个结合的子集合
 boolean  isEmpty(); 判断一个集合是否为空

2.4便利集合中的数据

3中方法

        1. for循环遍历

1. 增强for循环遍历【重点】 3. 迭代器【重点】

2.4.1使用for循环遍历集合数据

​

2.4.2使用增强for循环

for(集合或数组的元素的数据类型  临时变量：集合或者数组){
​
}

/*
 * collection接口使用for循环遍历
 */
package com.y.op;
​
import java.awt.List;
import java.util.ArrayList;
import java.util.Collection;
​
​
public class Demo2 {
    public static void main(String[] args) {
        Collection<String> collection= new ArrayList<String>();
        collection.add("开放");
        collection.add("嘉豪");
        collection.add("帅比");
        collection.add("李宁");
        collection.add("世诚");
        System.out.println(collection);
        Object[] str = collection.toArray();
        for (int i = 0; i < str.length; i++) {
            System.out.println(str[i]);
        }
    }
​
}

/*
 * 使用增强for遍历
 */
package com.y.op;
​
import java.util.ArrayList;
import java.util.Collection;
​
public class Demo3 {
    public static void main(String[] args) {
        Collection<String> collection= new ArrayList<String>();
        collection.add("开放");
        collection.add("嘉豪");
        collection.add("帅比");
        collection.add("李宁");
        collection.add("世诚");
        System.out.println(collection);
        for (String string: collection) {
            System.out.println(string );
        }
    }
​
}

​

2.4.3使用迭代器【重点】

/*
 * 迭代器遍历
 */
package com.y.op;
​
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
​
public class Demo4 {
    public static void main(String[] args) {
        Collection<String> collection= new ArrayList<String>();
        collection.add("开放");
        collection.add("嘉豪");
        collection.add("帅比");
        collection.add("李宁");
        collection.add("世诚");
        System.out.println(collection);
        Iterator<String>iterator= collection.iterator();
        System.out.println(iterator.hasNext());
        System.out.println(iterator.next());
        System.out.println(iterator.hasNext());
        System.out.println(iterator.next());
        System.out.println(iterator.hasNext());
        System.out.println(iterator.next());
        System.out.println(iterator.hasNext());
        System.out.println(iterator.next());
        System.out.println(iterator.hasNext());
        System.out.println(iterator.next());
    }
​
}
​

2.5List接口

Collection父接口

List下面有自己独有的一些方法，子接口比父接口的功能全

子接口不但重写父接口所有的方法而且加了自己的独有方法

List接口存储数据的时候  有序的  可以重复
增:
    boolean  add(int index, E e);  在指定索引下标的位置插入一个数据
    boolean  addAll(int index, Collection<? extends E> c);
    在指定下标为位置 插入另外一个集合
删:
    E remove(int index); 通过索引删除数据，返回的是被删除的元素
改:
    E  set(int index, E e);在指定下标的元素  被别的元素替代，返回值是被替代吗的元素
查：
    size()
    toArray()
    contains()
    isEmpty()
    
    
    E get(int index);  获取指定的下标的元素
    int  indexOf(Object obj); 通过元素获取指定的下标的
    int  lastIndexOf(Object obj);获取指定元素的最后一次出现的位置
    List<E>  subList(int startIndex, int endIndex); 截取集合中的一段

2.6List接口数据遍历

2.6.1使用for循环

/*
 * List接口for循环遍历
 */
package com.y.op;
​
import java.util.ArrayList;
import java.util.Collection;
​
public class Demo5 {
    public static void main(String[] args) {
        Collection<Double> coll = new ArrayList<Double>();
        coll.add(34.5);
        coll.add(222.7);
        coll.add(56.7);
        System.out.println(coll);
        Object [] str = coll.toArray();
        for (int i = 0; i < str.length; i++) {
            System.out.println(str[i]);
        }
    }
​
}

​

2.6.2增强for循环

/*
 * list增强for
 */
package com.y.op;
​
import java.util.ArrayList;
import java.util.Collection;
​
public class Demo6 {
    public static void main(String[] args) {
        Collection<Character> collection = new ArrayList<Character>();
        collection.add('a');
        collection.add('有');
        collection.add('屁');
        collection.add('块');
        collection.add('放');
        System.out.println(collection);
        for (Character Character : collection) {
            System.out.println(Character);
        }
    }
​
}
​

2.6.3List迭代器

/*
 * list迭代器
 */
package com.y.op;
​
​
import java.util.ArrayList;
​
import java.util.List;
import java.util.ListIterator;
​
public class Demo9 {
    public static void main(String[] args) {
        List <String> list = new ArrayList<String> ();
        list.add("开放真是那个");
        list.add("开放真的那个");
        list.add("开放太那个");
        list.add("开放真是那个");
        list.add("开放真的那个");
        list.add("开放太那个");
        ListIterator <String> listIterator =  list.listIterator(list.size());
        while(listIterator.hasPrevious()) {hasPrevious是listIterator的实现方法   返回上一个元素并且光标向上一个；
            System.out.println(listIterator.previous());
        }
    }
​
}

​