package cn.itcast.p1.generic.demo;
import java.util.ArrayList;
import java.util.Iterator;
public class GenericDemo {
/**
* @param args
*/
public static void main(String[] args) {
int[] arr = new int[4];
// arr[0] = 3.0;
//如何将一个Integer类型转成String类型呢
//首先设计编程就不合理,不能将Integer和String放到同一个容器中
//也就是,在申明容器的时候,只能装同一种类型的元素,不同的类型就用不同的容器装
ArrayList<String> al = new ArrayList<String>();
al.add("abc");//public boolean add(Object obj)
al.add("hahah");
// al.add(4);//al.add(new Integer(4));
Iterator<String> it = al.iterator();
while(it.hasNext()){
String str = it.next();
System.out.println(str);
}
}
}
package cn.itcast.p1.generic.demo;
import java.util.Iterator;
import java.util.TreeSet;
import cn.itcast.p2.bean.Person;
import cn.itcast.p3.comparator.ComparatorByName;
public class GenericDemo2 {
/**
* @param args
*/
public static void main(String[] args) {
TreeSet<Person> ts = new TreeSet<Person>(new ComparatorByName());
ts.add(new Person("lisi8",21));
ts.add(new Person("lisi3",23));
ts.add(new Person("lisi",21));
ts.add(new Person("lis0",20));
Iterator<Person> it = ts.iterator();
while(it.hasNext()){
Person p = it.next();
System.out.println(p.getName()+":"+p.getAge());
}
}
}
package cn.itcast.p2.bean;
public class Person implements Comparable<Person> {
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public int compareTo(Person p){
// Person p = (Person)obj;
int temp = this.age - p.age;
return temp==0?this.name.compareTo(p.name):temp;
}
//!!!!用IDE快捷生成,重写hashCode对应本类属性的判断唯一性,将重复的对象去掉
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person1111:"+getName()+":"+getAge();
}
package cn.itcast.p3.comparator;
import java.util.Comparator;
import cn.itcast.p2.bean.Person;
public class ComparatorByName implements Comparator<Person> {
@Override
public int compare(Person o1, Person o2) {
int temp = o1.getName().compareTo(o2.getName());
return temp==0? o1.getAge()-o2.getAge(): temp;
}
}
分享到:
相关推荐
1. 性能优势:由于类型安全和运行时无需装箱/拆箱,`List<T>`比非泛型的`ArrayList`有更好的性能。 2. 避免频繁扩容:在知道大概元素数量的情况下,可以预设容量以减少扩容次数,提高效率。 3. 避免大量插入和删除:...
泛型类的实例化必须提供实际类型参数,如`List<String> list = new ArrayList<String>()`。不过,对于无参构造函数的类,可以通过类型推断简化实例化,如`List<String> list = new ArrayList<>()`。 11. 类型参数...
- `<< >>= <= >= == !=`:比较运算符。 - `&& || !`:布尔运算符。 5. **预处理指令**: - `#include <library_name>`:包含标准库。 - `#include "stuff.h"`:包含用户定义的头文件。 - `using namespace ...
- `ArrayList<Object> lists = new ArrayList<String>();` - `ArrayList<String> lists = new ArrayList<Object>();` - `ArrayList<String> lists = new ArrayList();` - `ArrayList lists = new ArrayList...
我们可以使用`std::vector<int>`、`std::vector<double>`或者`std::vector<std::string>`来实例化,每个实例都有自己的成员函数和操作,但底层逻辑保持一致。 在实际编程中,模板还有许多高级用法,如模板特化...
- 泛型类的实例化必须提供实际类型参数,如`MyList<String> list = new MyList<>();` - 对于无参构造的泛型类,可以使用匿名内部类的方式省略尖括号,如`new MyList<String>() {}`。 9. 泛型和静态方法: - 泛型...
这导致了不能实例化泛型类型(如`new ArrayList<String>()`),因为实际生成的是`ArrayList<Object>`。 7. 创建非类型安全的集合与类型安全的集合: - 旧方式:`List list = new ArrayList();` 这种方式在添加元素...
- 实例化泛型(Instantiation):在使用泛型时,为类型参数提供具体类型,如 `Box<Integer>` 或 `List<String>`。 2. 泛型类: - 定义:`class MyClass<T> { ... }`,这里的 `T` 是类型参数,可以在类的方法和...
- 示例:`List<Integer> list = new ArrayList<>();` - **Map**:存储键值对的集合。 - 示例:`Map<String, Integer> map = new HashMap<>();` 4. **使用类型参数** - **类型参数**:定义泛型类或方法时使用的...
* 使用泛型:ArrayList<Integer> al2=new ArrayList<Integer>(); al2.add(new Integer(10)); Integer i2=al2.get(0); // 这里不必做强制类型转换。 泛型基础: * 在定义泛型类或声明泛型类的变量时,使用尖括号来...
例如,ArrayList<BankAccount> 可以存储 BankAccount 对象,而 ArrayList<String> 可以存储字符串对象。泛型类可以提高代码的可读性和可维护性。 泛型方法(Generic Method) --------------------- 泛型方法是一...
ArrayList<Integer> list = new ArrayList<>(); list.add(1); list.add(2); list.add(2); list.add(3); list.add(4); list.add(4); list.add(5); System.out.println("去重后的列表: " + removeDuplicates...
> list1 = new ArrayList<Object>();` ### 可变参数 #### 2. 可变参数的介绍与使用 - **概念**:可变参数允许方法接受不定数量的参数。 - **语法**:`修饰符 返回值类型 方法名(类型... 参数名) {}` - 示例:`...
本文将详细解释`IEnumerable<T>`、`IEnumerable`、`ICollection<T>`、`IList<T>`、`ObservableCollectin<T>`以及`Collection<T>`之间的关系。 首先,`IEnumerable<T>`接口是基础,它定义了一个可以被枚举(即遍历)...
在C#编程中,ArrayList和List<T>是两种常见的动态数组类型,它们都在.NET框架的System.Collections命名空间和System.Collections.Generic命名空间下,用于存储和操作对象数组。然而,尽管它们在用途上相似,但两者在...
day14-ArrayList集合 1.ArrayList 1.1ArrayList类概述【理解】 ...ArrayList<String> array = new ArrayList<String>(); //添加元素 array.add("hello"); array.add("world"); array.add("java");
ArrayList<String> names = new ArrayList<String>(); names.add("Ben"); names.add("Cat"); names.add(0, "Amy"); System.out.println(names); // [Amy, Ben, Cat] ``` 六、ArrayList 类的泛型 从 Java 5 开始,...
在Java中,像`ArrayList<String> arrayList1 = new ArrayList<Object>()`这样的引用传递是不允许的。这是因为,泛型出现的原因就是为了解决类型转换的问题,而这种引用传递违背了泛型设计的初衷。在这种情况下,如果...
错误的语句是:`ArrayList<String> lists = new ArrayList<Object>();` 和 `ArrayList lists = new ArrayList<String>();`。前者违反了类型安全,因为不能将 `ArrayList<Object>` 赋值给 `ArrayList<String>`。后者...