标签：01 java System 8.24 集合 add println Week2 out
集合01 8.24
-
什么是集合：
- 集合和数组类似，可以保存一组元素，并且提供了操作数组元素的方法，使用方便。
-
Java集合框架接口
- Java.util.Collection接口：所有结合的接口，封装了所有集合共有的内容。下面有多个实现类，有更多的数据结构可以选择。
- Collection接口下面还有常见的子接口：
- List ，线性表，可以重复集合
- Set ，不可重复，无序
- Map，键值对K-V
-
常见操作
- add():
- size():
- isEmpty():
- clear():
- contains():
- remove()：从集合中删除给定元素，成功删除返回true.
- addAll()：将参数给定的集合中的所有元素添加到当前集合中，添加后当前集合发生改变则返回true
- containsAll()：判断当前集合中是否包含参数集合中的所有元素
- retainAll()：取交集
- removeAll()：删交集
-
集合的遍历：
- Collection接口提供了统一的遍历集合的方式：迭代器模式。通过iterator()方法可以获取一个用于遍历当前集合元素的迭代器(Iterator接口)。
- java.util.Iterator接口：定义了迭代器遍历集合的相关操作。不同的集合都实现了用于遍历自身元素的迭代器实现类，我们无需记住它们的名字，从多态的角度把它们看成Iterator即可。
- 迭代器遍历遵循的步骤为：问、取、删，其中删除元素并不是必要操作
-
-
JDK1.5时推出了一个特性：增强型for循环，也称为新循环，让我们使用相同的语法遍历集合和数组。
-
语法：
for(元素类型 变量名 : 集合或数组){ 循环体 }
-
-
由于集合没有下标，需要用迭代器来遍历
迭代器操作：问，取 ，删除
快捷键itit
增强for循环，jdk1.5以后的新功能
语法： for（元素类型 变量名：数组或集合）{
循环体
-
泛型
-
jdk1.5的新特性：泛型
-
泛型也是参数化类型。允许我们在使用类中指定它当中的属性和方法、参数或返回值，使得使用更加方便。
- 泛型在集合中被广泛使用
-
-
集合与数组的转换：
- 数组转换为List集合：
- List集合转为数组：
package com.mlyStudyJava.collection_; import java.util.Objects; public class Point { private int x; private int y; //构造方法，构造方法器是与类名一致。 public Point(int x, int y) { this.x = x; this.y = y; } //toString 从地址->数值 @Override public String toString() { return "Point{" + "x=" + x + ", y=" + y + '}'; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Point point = (Point) o; return x == point.x && y == point.y; } //get set x,y public int getX() { return x; } public void setX(int x) { this.x = x; } public int getY() { return y; } public void setY(int y) { this.y = y; } }
package com.mlyStudyJava.collection_;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
public class Collection01 {
public static void main(String[] args) {
Collection c = new ArrayList();
c.add("one");
c.add("two");
c.add("three");
c.add("four");
c.add("five");
boolean b = c.add("six");
System.out.println(c);//Collection重写了Object的toString方法
int size = c.size();
System.out.println("size:"+size);
boolean isEmpty = c.isEmpty();
System.out.println("是否是空集：" +isEmpty);
c.clear();
System.out.println(c);
System.out.println("size:"+c.size());
System.out.println("是否为空集："+c.isEmpty());
}
}
package com.mlyStudyJava.collection_;
import java.util.ArrayList;
import java.util.Collection;
public class Collection02 {
public static void main(String[] args) {
Collection c = new ArrayList();
c.add(new Point(1,2));
c.add(new Point(3,4));
c.add(new Point(5,6));
c.add(new Point(7,8));
c.add(new Point(9,0));
c.add(new Point(1,2));
//集合 的 Point重写了Object的toString()方法
//前提是要在Point中先重写，如果不重写也不行，输出就是内存地址
//[元素1.toString(),元素2.toString(), ....]
System.out.println(c);
}
}
package com.mlyStudyJava.collection_;
import java.util.ArrayList;
import java.util.Collection;
public class Collection03 {
public static void main(String[] args) {
Collection c = new ArrayList();
c.add(new Point(1,2));
c.add(new Point(3,4));
c.add(new Point(5,6));
c.add(new Point(7,8));
c.add(new Point(9,0));
c.add(new Point(1,2));
final Point p = new Point(1, 2);
//判断c中是否包含p，判断依据是p是否与集合元素存在equals为true的情况
//当point重写equals后就会变T 因为equals比较值,不然还是F原来比较对象地址
boolean contains = c.contains(p);
System.out.println("是否包含："+contains);//F 未重写p的euqals
System.out.println("是否包含："+contains);//T 重写后
/**
* boolean remove ()
* 从集合中删除给定元素equals比较true ，若存在重复元素删除
*/
c.remove(p);
System.out.println(c);
}
}
package com.mlyStudyJava.collection_;
import java.util.ArrayList;
import java.util.Collection;
public class Collection04 {
public static void main(String[] args) {
Collection c1 = new ArrayList();
c1.add("java");
c1.add("c++");
c1.add(".net");
System.out.println(c1);//[java,c++,net]
System.out.println("===============");
Collection c2 = new ArrayList();
c2.add("android");
c2.add("ios");
c2.add("java");
System.out.println(c2);//[android,ios,java]
/**
* boolean addAll(Collection c)
* 将参数给定的集合中所有的元素添加到当前集合，添加后当前集合后发生改变返回
*/
c1.addAll(c2);
System.out.println("c1:"+c1);
System.out.println("c2:"+c2);
System.out.println("==================");
Collection c3 = new ArrayList();
c3.add("c++");
c3.add("android");
c3.add("php");
System.out.println("c3:"+c3); //[c++,android,php]
/**
* boolean containsAlL(Collection c)
* 判断集合中是否包含参数的所有集合
*/
boolean contains = c1.containsAll(c3);//判断c1中是否包含c3
System.out.println("是否包含所有："+contains);
System.out.println("====================");
//取交集 c1中仅保留c1与c3的共有元素，c3不变
// c1.retainAll(c3);
//
// System.out.println("c1:"+c1);
// System.out.println("c3:"+c3);
// System.out.println("====================");
c1.removeAll(c3);
System.out.println("c1:"+c1);
System.out.println("c3:"+c3);
}
}
package com.mlyStudyJava.collection_;
import java.util.ArrayList;
import java.util.Collection;
public class Collection05 {
public static void main(String[] args) {
Collection c = new ArrayList();
Point p = new Point(1, 2);
c.add(p);
System.out.println("p:" + p); //(1,2)
System.out.println("c:" + c);//[(1,2),(3,4)]
}
}
package com.mlyStudyJava.collection_;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
/*
集合转换成数组
Collection->toArray可以将当前集合转换为数组
*/
public class CollectionToArray01 {
public static void main(String[] args) {
Collection<String > c = new ArrayList<>();
c.add("one");
c.add("two");
c.add("three");
c.add("four");
c.add("five");
System.out.println(c);
System.out.println("=========================");
String[] array = c.toArray(new String[8]);
/**
* 若参数的数组元素=集合元素个数，就正常转换
* 若参数的数组元素>集合元素个数，就正常转换，同时末尾补默认值
* 若参数的数组元素<集合元素个数，就会按照集合大小给数组
*/
System.out.println(Arrays.toString(array));
}
}
package com.mlyStudyJava.collection_;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class GenericDemo {
public static void main(String[] args) {
Collection<String> c = new ArrayList<>();
c.add("one");
c.add("two");
c.add("three");
//c.add(123);//编译错误，参数类型违背了集合c所指定的泛型E，应该是String
Iterator<String> it =c.iterator();
while(it.hasNext()){
String str = it.next();
System.out.println(str);
}
System.out.println("==============");
for(String str:c){
System.out.println(str);
}
}
}
package com.mlyStudyJava.collection_;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
* 集合的遍历：
*/
public class Iterator01 {
public static void main(String[] args) {
Collection c = new ArrayList();
c.add("one");
c.add("#");
c.add("two");
c.add("#");
c.add("three");
c.add("#");
c.add("four");
c.add("#");
c.add("five");
System.out.println(c); //[one, #, two, #, three, #, four, #, five]
/*
迭代器的常用方法
1.boolean hasNext() -----问
询问集合是否还有“下一个”元素可供迭代
注意：迭代器默认开始位置是在初始位置之前 -1的位置 应该是指针
无论调用多少次hasNext()方法，迭代器的位置都不会变
2.Object next()-------------取
迭代器向后移动一个位置来指向集合的下一个元素并将其获取
*/
Iterator it =c.iterator();//获取集合c的迭代器 c.iterator.var
while (it.hasNext()) {//若有下一个元素
String str =(String)it.next();//获取下一个元素
if("#".equals(str)){
//c.remove(str);集合的长度不能变
it.remove();//删除所取的元素
}
System.out.println(str);
}
System.out.println(c);
}
}
package com.mlyStudyJava.collection_;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class NewFor {
public static void main(String[] args) {
String[] array ={"one","two","three","four","five"};
for (int i = 0; i <array.length ; i++) {
// String str = array[i];
System.out.println(array[i]);
}
System.out.println("================");
Collection c =new ArrayList();
c.add("one");
c.add("two");
c.add("three");
c.add("four");
c.add("five");
Iterator it = c.iterator();
while (it.hasNext()) {
Object next = it.next();
System.out.println(next);
}
System.out.println("================");
//新的for循环遍历数组
for(String str :array){
System.out.println(str);
}
System.out.println("================");
for(Object obj :c){
//String str=(String)obj;
System.out.println(obj);
}
}
}
标签：01,java,System,8.24,集合,add,println,Week2,out 来源： https://www.cnblogs.com/maluyi/p/16621234.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。