c#中泛型集合怎样写强制类弄转换
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了c#中泛型集合怎样写强制类弄转换相关的知识，希望对你有一定的参考价值。
有一个方法，返回List<object>，怎样赋值给一个 List<自定义对象> 变量 ？ 这里主要是强制类型转化不知怎样写， 比例 有一个变量 intvar是int类型，赋值给long 类型变量longvar, 则这样写 longvar=(long)intvar; 但这泛型集合 变类型 怎么写？
List<object> a = new List<object>();a.Cast<自定义对象>().ToList(); 参考技术A List<object> olist;
List<YourClass> flist = olist.ConvertAll(s => s as YourClass); 参考技术B List<object> a;
List<int> b=a.Cast<int>().ToList();本回答被提问者采纳
Java中泛型与集合
Java中泛型与集合
- 定义一个泛型累Point,包含x,y两个T类型成员，定义两个带参数的构造方法，定义translate()方法将点移到新的坐标
public class Point <T>{
T x, y ;
public Point(T x, T y){ //带两个参数的构造方法
this.x = x ;
this.y = y ;
}
public T getX(){ //访问方法
return x ;
}
public void setX(T x){ //修改方法
this.x = x ;
}
public T getY(){ //访问方法
return y ;
}
public void setY(T y){ //修改方法
this.y = y ;
}
public void translate(T newX, T newY){ //将点移动到新坐标的方法
this.x = newX ;
this.y = newY ;
}
@Override
public String toString(){ //重写字符串方法，返回坐标
return "(" + this.x + "," + this.y + ")" ;
}
public static void main(String[] args){
Point <Integer> point = new Point<>(3,5) ;
Point <Double> point1 = new Point<>(3.3, 5.5) ;
System.out.println(point) ;
point.setX(1) ;
point.setY(2) ;
System.out.println(point) ;
point.translate(3,4) ;
System.out.println(point) ;
System.out.println(point1) ;
}
}
- 创建一个元素是字符串的ArrayList对象，
- 在其中添加若干元素，用三种方法将每个字符串转换成大写
import java.util.ArrayList;
import java.util.Iterator;
public class UpperCaseDemo {
public static void main(String[] args){
ArrayList <String> names = new ArrayList<>() ;
names.add("Wang") ;
names.add("Tang") ;
names.add("li") ;
names.add("Yao") ;
for(int i=0; i<names.size(); i++){ //索引循环
String name1 = names.get(i) ; //得到对应集合下标元素
name1 = name1.toUpperCase() ; //转换成大写
names.set(i,name1) ; //设置对应集合元素
System.out.print(names.get(i) + " ") ; //访问对应集合元素
}
for(String name : names){ //增强for循环
System.out.print(name + " ") ;
}
System.out.println() ;
ArrayList <String> name3 = new ArrayList<>() ;
name3.add("Chen") ;
name3.add("Dai") ;
name3.add("Li") ;
name3.add("Tao") ;
Iterator iterator = name3.iterator() ; //使用迭代器的方式输出
while(iterator.hasNext()){
String name2 = (String)iterator.next() ;
name2 = name2.toUpperCase() ;
iterator.remove() ;
System.out.print(name2 + " ") ;
}
ArrayList <String> name4 = new ArrayList<>() ;
name4.add("Hu") ;
name4.add("Ye") ;
name4.add("Liu") ;
name4.add("Xue") ;
name4.replaceAll(String::toUpperCase) ;
for(String s : name4){
System.out.print(s + " ") ;
}
}
}
- 将一个字符串的单词解析出来，然后将它们添加到HashSet中， 输出每个重复的单词，不同单词的个数，消除重复单词后的列表
import java.util.HashSet;
import java.util.Set;
public class FindDuplicate {
public static void main(String[] args){
Set <String> unique = new HashSet<>() ;
Set <String> duplicate = new HashSet<>() ;
String message = "My name name Wang Guo dong" ;
String [] words = message.split(" ") ; //将字符串按空格划分成数组
for(String a : words) {
if (!unique.add(a)){ //如果不在unique集合中，则是重复的元素
duplicate.add(a) ;
}
}
System.out.println("不同单词的个数" + unique.size()) ;
System.out.println("不重复的单词" + unique) ;
unique.removeAll(duplicate) ;
System.out.println("重复的单词" + duplicate) ;
}
}
- 随机生成10个两位数，并将其分别存入HashSet和TreeSet
- 然后输出，观察输出结果的不同
import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;
public class SetDemo {
public static void main(String[] args){
int [] elements = new int [10] ;
Set <Integer> hs = new HashSet<>() ;
Set <Integer> ts = new TreeSet<>() ;
for(int i=0; i<10; i++){
elements[i] = (int)(Math.random() * 90 + 10) ;
hs.add(elements[i]) ;
ts.add(elements[i]) ;
}
for(Integer a : hs){ //HashSet是不重复元素的无顺序输出
System.out.print(a + " ") ;
}
System.out.println() ;
for(Integer b : ts){ //TreeSet是不重复元素的升序输出
System.out.print(b + " ") ;
}
}
}
- 定义一个对象栈类，要求使用ArrayList类实现该栈
import java.util.ArrayList;
public class MyStack <T>{
private ArrayList<T> list ;
public MyStack(){
list = new ArrayList<T>() ;
}
public void push(T obj){ //将元素添加到栈顶
list.add(0,obj) ;
}
public T pop(){ //将元素从栈顶移除
return list.remove(0) ;
}
public T peek(){ //访问栈顶元素
return list.get(0) ;
}
public int getSize(){ //返回栈中元素个数
return list.size() ;
}
public boolean isEmpty(){ //对栈判空操作
return list.isEmpty() ;
}
public int search(T t){
return list.indexOf(t) ;
}
public static void main(String[] args){
MyStack<Integer> myStack = new MyStack<>() ; //实例化对象
myStack.push(1) ; //将元素1，2，3入栈
myStack.push(2) ;
myStack.push(3) ;
System.out.println(myStack.search(2)) ; //查找指定元素的位置
System.out.println(myStack.peek()) ; //访问栈顶元素
System.out.println(myStack.getSize()) ; //返回栈中元素个数
myStack.pop() ; //栈顶元素出栈
myStack.pop() ;
myStack.pop() ;
System.out.println(myStack.isEmpty()) ; //判空
}
}
- 假设Employee类包含一个int型id成员，如果要求Employee可按id值比较大小
- 创建几个Employee对象，并将它放到TreeSet中输出
import java.util.TreeSet;
public class Employee implements Comparable<Employee>{ //实现Comparable接口
private int id ;
private String name ;
public Employee(int id, String name){
this.id = id ;
this.name = name ;
}
@Override
public int compareTo(Employee obj) { //重写CompareTo()方法
return this.id - obj.id;
}
public static void main(String[] args){
Employee [] myList = new Employee[3] ;
myList[0] = new Employee(2,"王国栋") ;
myList[1] = new Employee(1,"唐乃乔") ;
myList[2] = new Employee(3,"陈向军") ;
TreeSet <Employee> employList = new TreeSet<>() ;
employList.add(myList[0]) ;
employList.add(myList[1]) ;
employList.add(myList[2]) ;
for(Employee employee : employList){
System.out.print(employee.id + " " + employee.name) ;
}
}
- PriorityQueue是Queue接口的一个实现类，实现一种优先级队列
- 创建一个PriorityQueue对象，将整形数组{1，5，3，7，6，9，8}插入队列
- 观察输出结果
import java.util.PriorityQueue;
import java.util.Queue;
public class PriorityQueueDemo {
public static void main(String[] args){
Queue <Integer> queue = new PriorityQueue<>() ;
int [] value = new int[]{1,5,3,7,6,9,8} ;
for(int number : value){
queue.add(number) ;
}
while(!queue.isEmpty()){
System.out.print(queue.remove() + " ") ;
}
}
}
- 编写程序，生成1000个随机生成的三位整数的流，过滤该流
- 使其进包含能被7整除或 含有7的数，输出这些数和个数
import java.util.stream.IntStream;
public class IntStreamDemo {
public static void main(String[] args){
int [] value = new int [1000] ;
for(int i=0; i<value.length; i++){ //生成一个随机的三位整数
value[i] = (int)(Math.random() * 900 + 100) ;
}
IntStream intStream = IntStream.of(value) ; //生成整数流
//过滤流
intStream = intStream.filter(number -> (number % 7 == 0 || number % 10 == 7 || number / 10 % 10 == 7 || number / 100 == 7)) ;
int [] result = intStream.toArray() ; //流中元素存入数组
for(int elements : result){
System.out.print(elements + " ") ;
}
}
}
- 编写程序，分别使用顺序流和并行流计算10,20,30,40这几个数的阶乘
- 输出结果并计算完成时间，使用并行流是否比使用顺序流快
import java.math.BigInteger;
import java.time.Duration;
import java.time.Instant;
import java.util.Arrays;
import java.util.List;
public class ParallelStreamDemo {
public static BigInteger f(long n){ //计算n的阶乘
BigInteger result = new BigInteger("1") ;
for(long i=1; i<=n; i++){
result = result.multiply(new BigInteger(i + "")) ;
}
return result ;
}
public static void main(String[] args){
Integer [] value = {10,20,30,40} ;
List <Integer> list = Arrays.asList(value) ; //将数组元转换成集合
Instant start = Instant.now() ; //开始时间
list.parallelStream().map(input -> f(input)).forEach(System.out::println);
Instant end = Instant.now() ; //结束时间以上是关于c#中泛型集合怎样写强制类弄转换的主要内容，如果未能解决你的问题，请参考以下文章