标签：方式 前序遍历 扩容 arraylist 红黑树 超过 ++ 面向接口 方法返回值
导读：你还在为集合类而烦恼吗？别担心，我花了几天时间整理了一下集合类，文章通俗易懂，看完这篇文章保证让你茅塞顿开。内容很全，所以文章有点长,建议收藏再看。
import java.util.ArrayList;
import java.util.Collection;
public class CollectionTest1 {
public static void main(String[] args) {
//多态
Collection W = new ArrayList();
// 自动装箱
W.add(200);
W.add(new Object());
// 自动装箱
W.add(true);
// 获取集合的元素
System.out.println(W.size());
// 清空集合
W.clear();
W.add("浩克");
System.out.println(W.contains("浩克"));
// 删除集合中特定元素
W.remove("浩克");
System.out.println(W.isEmpty());
W.add("皮卡丘");
W.add("大熊猫");
Object[] objs = W.toArray();
for(int i=0 ;i<objs.length;i++){
Object O = objs[i];
System.out.println(O);//自动调toString方法
}
}
}
Contains（Object O ）方法的进阶（选读（如果看不懂建议去复习一下Object的equals方法），因为涉及equals方法得内容）。你可以猜测一下以下代码的执行结果。
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
public class ColletionTest2 {
public static void main(String[] args) {
Collection c = new ArrayList();//多态
c.add("abc");
c.add("100");
c.add("def");
c.add(100);
c.add(new Object ());
// 遍历
Iterator it = c.iterator();//获得迭代器
// 第二步：通过获得的迭代器遍历集合。
while(it.hasNext()){
Object obj = it.next();
System.out.println(obj);
}
}
}
答案为：true,你答对了吗？ArrayList集合确实不包含x,下面来分析一下内存结构：
import java.util.ArrayList;
import java.util.Collection;
public class CollectionTest4 {
public static void main(String[] args) {
Collection c =new ArrayList();
String u1 = new String("abc");
c.add(u1);
String u2 = new String ("abc");
c.remove(u2);
System.out.println(c.size());
}
}
你可能感到奇怪这个方法为什么单独讲，这就不用我说了吧。因为很重要，所以加油呀。
Iterator为Iterable中的方法，被Collection接口继承。
解释：Collection接口以及子类调用父类Iterable方法:iterator();放回一个迭代器Iterator对象。（不要搞混哦，注意首字母的大小写，大小写不同，含义不同。）
遍历集合/迭代集合，以下讲解的遍历/迭代方式，是所有Collection以及子类通用的一种方法，但是在Map集合中不能使用。
迭代器的执行原理：
迭代器 Iterator对象，的三个方法：
迭代器最初并没有指向第一个元素。
boolean hasNext()方法：如果还有元素可以迭代返回true.
Object next();这个方法让迭代器往前进一位，并且返回指向的元素。
两个方法配合实现迭代。
第三个方法remove（）后期聊。
练习：
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
public class ColletionTest2 {
public static void main(String[] args) {
Collection c = new ArrayList();//多态
c.add("abc");
c.add("100");
c.add("def");
c.add(100);
c.add(100);
c.add(new Object ());
// 遍历
Iterator it = c.iterator();//获得迭代器
// 第二步：通过获得的迭代器遍历集合。
while(it.hasNext()){
Object obj = it.next();
System.out.println(obj);
}
}
}
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionTest5 {
public static void main(String[] args) {
Collection c =new ArrayList();
c.add(15);
c.add("fas");
c.add(2222);
Iterator it = c.iterator();
while (it.hasNext()){
Object o = it.next();
it.remove();//用迭代对象的remove方法删除
System.out.println(o);
}
System.out.println(c.size());
}
}
import java.util.*;
public class ListTest1 {
public static void main(String[] args) {
List myList = new LinkedList();
// List myList2 = new ArrayList();
// List myList3 = new Vector();
// 添加元素
myList.add("cad");
myList.add("dfsa");
myList.add(6656);
myList.add(6656);//默认在最后添加
myList.add(1,"King");//在指定位置添加元素
Iterator it = myList.iterator();
while (it.hasNext()){
Object o = it.next();
System.out.println(o);
}
// 获取特定元素
Object obj = myList.get(1);
System.out.println(obj);
// 获取指定对象最后一次出现的索引
System.out.println(myList.lastIndexOf(6656));
// 修改特定位置的元素
myList.set(0,"fdafasdf");
System.out.println(myList.get(0));
}
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class VectorTest1 {
public static void main(String[] args) {
List myList = new ArrayList();
// 变成线程安全的
Collections.synchronizedList(myList);
myList.add("444");
System.out.println(myList.get(0));
}
}
import java.util.Set;
import java.util.TreeSet;
public class TreeSetTest1 {
public static void main(String[] args) {
Set<String> aa = new TreeSet<>();
aa.add("a");
aa.add("g");
aa.add("c");
aa.add("d");
for(String cc : aa){//foreach，详情请看下文
System.out.println(cc);
}
}
}
public class MapTest2 {
public static void main(String[] args) {
//创建map集合对象
Map<Integer,String>map = new HashMap<>();
//添加键值对
map.put(1,"zhangshan");
map.put(2,"daf");
map.put(3,"fa");
//通过key获取value
String c = map.get(2);
System.out.println(c);
//获取键值对的数量
System.out.println(map.size());
//获取所有的value
Collection<String> values = map.values();
for(String s : values){
System.out.println(s);
}
//通过key删除key-value
map.remove(2);
System.out.println(map.size());
//判断是否包含某个key，value
System.out.println(map.containsKey(5));
System.out.println(map.containsValue("fa"));
//清空键值对
map.clear();
System.out.println(map.size());
}
}
package Day3;
import java.util.HashSet;
import java.util.Set;
public class MapTest1 {
// 声明静态内部类
private static class InnerClass{
public static void m1(){
System.out.println("静态方法m1执行！");
}
// 实例方法
public void m2(){
System.out.println("实例方法执行！");
}
}
public static void main(String[] args) {
MapTest1.InnerClass.m1();
MapTest1.InnerClass aa= new MapTest1.InnerClass();
aa.m2();
Set<InnerClass> set = new HashSet<>();
Set<MyMap.MyEntry<Integer,String >> set3 =new HashSet<>();
}
}
class MyMap{
public static class MyEntry<k,v>{
}
}
public class MapTest3 {
public static void main(String[] args) {
Map<Integer,String> map = new HashMap();
map.put(1,"sff");
map.put(2,"fasdf");
map.put(5,"fasdf");
map.put(3,"fasd");
//获取所有的key
Set<Integer> keys = map.keySet();
/* Iterator<Integer> it = keys.iterator();
while (it.hasNext()){
Integer key = it.next();
String value = map.get(key);
System.out.println(key+"="+ value);
}*/
for(Integer key :keys){
System.out.println(key+"="+map.get(key));
}
//第二种方法直接转换成Set集合。
//Set集合中元素的类型是：Map.Entry
Set<Map.Entry<Integer,String >> set = map.entrySet();
/*Iterator<Map.Entry<Integer,String>> it2 = set.iterator();
while (it2.hasNext()){
Map.Entry<Integer,String> node = it2.next();
Integer key = node.getKey();
String value = node.getValue();
System.out.println(key+"="+value);
}*/
for(Map.Entry<Integer,String>node:set){
System.out.println(node.getKey()+"="+node.getValue());
}
}
}
public class HashMapTest1 {
public static void main(String[] args) {
Map<Integer,String> map = new HashMap<>();
map.put(888,"fas");
map.put(888,"fasf");
map.put(77,"fa");
map.put(55,"fdfda");
System.out.println(map.size());
Set<Map.Entry<Integer,String>> set = map.entrySet();
for(Map.Entry<Integer,String > a: set){
System.out.println(a.getKey()+"-->"+a.getValue());
}
}
}
public class PropertiseTest1 {
public static void main(String[] args) {
Properties pro= new Properties();
pro.setProperty("url","dfaf");
pro.setProperty("fasd","fasd");
//通过key获取value
String a=pro.getProperty("url");
String b= pro.getProperty("fasd");
String c =pro.getProperty("url");
String d =pro.getProperty("fasd");
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
}
}
public class ComparableTest1 {
public static void main(String[] args) {
Customer c1 = new Customer(32);
Customer c2 = new Customer(22);
Customer c3 = new Customer(18);
// 创建TreeSet集合
TreeSet<Customer>customers = new TreeSet<>();
// 添加元素
customers.add(c1);
customers.add(c2);
customers.add(c3);
// 遍历
for(Customer c :customers){
System.out.println(c);
}
}
}
//放在TreeSet集合中的元素要实现Comparable接口，并且实现compareTo方法，equals可以不写
class Customer implements Comparable<Customer>{
private int age;
public Customer() {
}
public Customer(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public int compareTo(Customer o) {
return this.age-o.age;
}
@Override
public String toString() {
return "Customer{" +
"age=" + age +
‘}‘;
}
}
public class TreeSetTest3 {
public static void main(String[] args) {
// 创建TreeSet集合的时候，需要使用比较器
// TreeSet<WuGui> wuGui =new TreeSet<>(new WuGuiComparator());
// 一下采用匿名内部类，简化程序,(没有名字，直接new接口，大括号，为接口的实现）
TreeSet<WuGui>wuGui = new TreeSet<>(new Comparator<WuGui>() {
@Override
public int compare(WuGui o1, WuGui o2) {
return o1.age-o2.age;
}
});
wuGui.add(new WuGui(1000));
wuGui.add(new WuGui(1200));
wuGui.add(new WuGui(20));
for(WuGui wu:wuGui){
System.out.println(wu);
}
}
}
//
class WuGui{
int age;
public WuGui(int age) {
this.age = age;
}
@Override
public String toString() {
return "WuGui{" +
"age=" + age +
‘}‘;
}
}
/*
//单独编写一个比较器，实现Comparator接口(util包下，而Comparable接口是在lang包）
class WuGuiComparator implements Comparator<WuGui>{
@Override
public int compare(WuGui o1, WuGui o2) {
return o1.age-o2.age;
}
}*/
总结：放到TreeSet或TreeMap集合key部分的元素要想做到排序，有两者方式：
第一种：实现lang包下的Comparable接口。
第二种：在构造TreeSet或TreeMap集合的时候给他传一个比较器对象。（实现Comparator接口）。比较规则不变的情况建议使用comparable,经常发生改变使用Comparator接口。
ublic class CollectionsTest1{
public static void main(String[] args) {
List<String > list = new ArrayList();
// 变成线性安全的
Collections.synchronizedList(list);
// 排序,当遇到自定义类排序时需要实现Comparable或则Comparator接口，大部分API都重写了
list.add("ad");
list.add("fa");
list.add("fad");
Collections.sort(list);
for (String s:list){
System.out.println(s);
}
}
}
package Day3;
import java.util.*;
public class FanXingTest1 {
public static void main(String[] args) {
List<Animal> myList = new ArrayList<Animal>();//jdK8之后，后面的Animal可以不写。
Cat a = new Cat();
Bird b = new Bird();
myList.add(a);
myList.add(b);
Iterator<Animal> it = myList.iterator();
while (it.hasNext()){
Animal aa =it.next();
aa.move();
}
}
}
class Animal{
public void move(){
}
}
class Cat extends Animal{
public void move(){
System.out.println("猫儿抓老鼠");
}
public void Sleep(){
System.out.println("猫睡觉！");
}
}
class Bird extends Animal{
public void move() {
System.out.println("鸟儿飞！");
}
}
示例：
package Day3;
public class FanXingTest2<abc> {
public static void main(String[] args) {
FanXingTest2<String> aa= new FanXingTest2<>();
aa.doSome("fad");
}
public void doSome(abc o){
System.out.println(o);
}
}
import java.util.*;
public class ArrayListTest1 {
public static void main(String[] args) {
List w = new ArrayList(100);
Collection c = new HashSet();
c.add(100);
c.add(454);
c.add(100);
List<Integer> myList = new ArrayList<>(c);
for(Integer a : myList){
System.out.println(a);
}
/*for(int i = 0;i<myList.size();i++){
System.out.println(myList.get(i));
}*/
/*Iterator it = myList.iterator();
while (it.hasNext()){
Object o = it.next();
System.out.println(o);
}*/
}
}
标签：方式 前序遍历 扩容 arraylist 红黑树 超过 ++ 面向接口 方法返回值
原文地址：https://www.cnblogs.com/huangjiahuan1314520/p/12683912.html
