public static ArrayList getSingle(ArrayList list)
ArrayList newlist = new ArrayList(); //创建一个新集合
Iterator it = list.iterator;
whlie(it.hasNext);
Object obj = it.next()
if (newList.contaiins(obj))
newLissuest.add(obj);
return newList;
集合框架去除:
containcontains方法.判断是否包含.底层依赖的是equals方法
记忆: ArrayList类中的两个方法
contains() 和remove()方法 顶层依赖的都是equals()
所以 如果去重对象是"自定义类型,不要忘了.equals()"
public lass Demo23 {
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
list.add(new Student1("路路", 30));ist.add(new Student1("小胡", 30));list.add(new Student1("高伟", 30));list.add(new Student1("可心", 30));ArrayList newList = getSigle(list);// 调用方法去除重复
System.out.println(newList);
list.remove(new person("粑粑",1)) // remove判断删除方法也是靠equals方法
System.out.println(list);
}
public static ArrayList getSigle(ArrayList list){
ArrayList newList = new ArrayList();
Iterator it = list.iterator();
while(it.hasNext()) {
Object obj = it.next();
if (!newList.contains(obj)) {
newList.add(obj);
}
}
return newList;
}
LinkedList:
添加.addFirst() 和addLast(); // 添加的功能
getFirst() 和gettlast() //获取
removeFirst() 和removeLast() // 删除
get(int index);
LinkedList list = new LinkedList();
list.addFirst("a");
list.addFirst("b");
list.addFirst("c");
list.addFirst("d");
list.addLast("e");
System.out.println(list.get(1));
System.out.println(list.getFirst());
System.out.println(list.getLast());
System.out.println(list.removeFirst());
System.out.println(list.removeLast());
System.out.println(list);
数据结构之栈和队列:
栈特点:
先进后出
例子/; 弹匣.
队列:
先进先出
例子. 排队打饭, 排队打卡 排队领工资.
面试题:重要:
用LinkedList模拟栈数据结构的集合并测试
addFirst()和addLast();
removeFirst()和removelast()
头:,"a","b","c","d" addLast()
出: removeLast()
LinkedList list = new LinkedList();
lias.addLast("a");
lias.addLast("b");
lias.addLast("c");
lias.addLast("d");
System.out.println(list.removeLast());
System.out.println(list.removeLast());
System.out.println(list.removeLast());
System.out.println(list.removeLast());
while(!list.isEmpty())
System.out.println(list.removeLast());
private LinkedList list = new LinkedList();
public void in(Object obj)
list.addLast(obj);
public Object out()
return list.removeLast();
public boolean isEmpty{
return list.isEmpty();
}
Stack s = new Stack();
s.in("b");
s.in("c");
s.in("d");
s.in("c");
while(!s.isEmpty())
System.out.println(s.out());
注意:这是一类题． 面试的时候如果看到这类题:"用**（一般是类）来模拟某个功能"
潜台词就是让我们对星星这个类进行封装 然后调用这个类中的一些方法 来实现功能
泛型:<>
泛型的概述:
好处提高安全性(将运行错误转到编译期)
省去强转的麻烦
可以解决Eclipse中的黄色警告线的问题.
ArrayList<person> list = new ArrayList()<person>;
list.add(new person(可可,23));
list.add(new person(啊磊,23));
list.add(new person(小胡,23));
list.add(new person(路路,23));
Iterator<person> it = list.iterator()
while(it.hasNext())
//System.out.println(it.next());
person p = it.next();
System.out.println(s.getName()+ "..." + s.getAge());
//System.out.println(it.next().getName()+ "..." + it.next().getAge()); 报错 next()智能调用一次 如果调用多次会将指针向后移动多次
person p = it.next();
System.out.println(p.getName()+ ".."+p.getAge());
泛型的基本使用:
在类<>中放的必须是引用数据类型
泛型使用注意事项:
前后泛型必须一致.或者后边的泛型可以省略不写.(1.7的心特性.菱形泛型)
推荐手写上.
int[] arr = new byte[5] //数组要保证前后数据类型一致
ArrayList<Object> list = new ArrayList<prerson>();
ArrayList<Object> list = new ArrayList();1.7版本菱形泛型
ArrayList(Object) list = new ArrayList<>();
list.add(ture);
ArrayList
String:
ArrayList(String) list = new ArrayList<>();
list.add("b")
list.add("c")
list.add("a")
list.add("d")
Iterator<String> it = list.iterator();
while(it.hasNext())
System.out.println(it.next());
Person:
ArrayList<Person> list = new ArrayList<>;
list.add(new person("张散"23));
list.add(new person(打算散"23));
list.add(new person("范德萨"23));
list.add(new person("高分段"23));
Iterator<Person> it = list.iterator();
while(it.hasNext())
Person p = it.next();
System.out.println(p.getName()+"..."+p.getAge());
泛型的由来:
Object转型问题引入
早起的Object类型可以接受任意对象类型,但是在实际的使用中 会有转型问题. 所以java提供了泛型功能
泛型应用:
泛型类概述: 就是把泛型加在类上
格式 public class 类名<泛型>{
}
事例: public class 类名<QQ> {
private QQ q;
}
泛型方法:
非静态方法:
实力 : public void show(QQ q){
System.out.println(q);
}
public<W> void method(W w) {
}
静态方法:
泛型必须在方法上定义:
public class 类名<QQ> {
public staticc<WW> void show(WW w) {
Systm.out.println(q);
}
}
泛型接口:
public interface 接口名<泛型>{
}
事例:
public interface Smoking<Q> {
如果一个类型实现了泛型接口
class Demo implements Smolking<Integer>{
}
1,在实现接口的时候 直接给出具体的类型(引用类型)
}
2.定义出自己的泛型
class Demo<Q> implements Smoking<Q>
泛型高级之通配符:
<?> 任意类型. 如果没有明确.那么就是Object以及任意的Java类了.
extends E 向下限定也叫固定上边界 E及其子类 大白话: 看到这个东西.就意味着我们可以放e类的对象也可以放e类的子类对象
super E 向上限定 E极其父类
大白话理解:看到这个东西就意味着: 可以放e类的对象也可以放E类的父类对象,
//List<?> list = new ArrayList<Integer>();
ArrayList<Person> list1 = new ArrayList<>();
list1.add(new Person("路路",23));
list1.add(new Person("可可",23));
list1.add(new Person("小胡",23));
list1.add(new Person("高伟",23));
ArrayList<Student>list2 = new ArrayList<>();
list2.add(new Student("阿磊",23));
list1.addAll(list2);
System.out.println(list1);
集合加强:
增强for:
简化数组和collection集合遍历
格式:
for(元素数据类型 变量: 数组或者collection)
使用变量即可 该变量就是元素
int[] arr = {11,22,33,44,6 };
for(int i : arr)
System.out.println(i);
快键 fore
ArrayList<String> list = new ArrayList<>()
list.add("a");
list.add("b");
list.add("c");
list.add("d");
for(String String : list)
System.out.println(String);
增强for:口述
for(元素的数据类型 变量名 : 要遍历的数组或者集合名)
直接用就可以了.
增强for循环底层依赖迭代骑
思考:通过普通for 迭代骑 增强for 遍历集合的时候 能不能删除集合中的元素
普通for循环删除 注意:索引要--
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
for(int i = 0 ; i< list.size() i++)
if("b").equals(list.get(i))
list.remove(i--);
System.out.printlin(list);
迭代骑删除:但是得调用大跌带起的remove()方法删除
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
Iterator<String> it = list.iterator();
while(it.hasNext())
if("b".equals(it.next())
//list.remove("b")
it.remove();
for(Iterator<String>) it2 = list.iterator();
if("b".equals(it2.next())
it2.remove();
System.out.printlin(list);
增强for循环不能删除 值能遍历
ArrayList<String> list = new ArrayList<>();
list.add("a");
,l,lpl hbunlist.add("b");
list.add("c")
for(String string : list)
if("b".equals(string))
list.remove("b")
System.out.println(list);
静态导入 : jdk1.5以后的特性
静态导入是导入类中的静态方法
格式 import static 包名 类名 方法名
可以直接导入到方法的级别
注意事项.方法必须是静态的.如果有多个同名的静态方法容易不知道使用谁这个时候要使用,必须加前缀 由此可见. 意义不大
开发不用.需要能看懂就可以,然并卵
int[] arr = {55,22,33,44,11};
Array.sort(arr);
System.out.println(Arrays.toString(arr));
可用参数: (jdk1.5的新特性)
应用概述:
定义方法的时候不知道该定义多少个参数的时候 就可以考虑用
格式:
修饰符 返回值类型 方法名(参数类型... 变量名)
注意事项:
1,这个的变量其实是一个数组
2,如果方法有多个形参,并且其中包含可变参数 那么可变参数肯定是参数列表的最后一个
int[] arr = {11,.22,33,44,55}
//print(arr);
print(11,22,33,44,55)
System.out.println("_________")
print();
public static void print(int[] arr)
for(int i = 0 i < arr.length i++)
System.out.println(arr[1])
public static void print(int ... arr)
for(int i = 0 i < arr.length i++)
System.out.println(arr[1]
集合和数组之间的相互转换:
集合转成数组:
Collection接口中的toArray();
集合转数组加泛型的:
ArrayList<String> list = new ArrayList<>();
list.add("b");
list.add("c");
list.add("d");
list.add("e");
String[] arr = list.toArray(new String[
for(String string : arr)
System.out.println(string);
|
收藏
淘帖
踩
