JAVA常用8种类的使用方法详解
Java8用法总结
Java8⽤法总结⼀、新特性Java8带来了很多的新特性,本篇就以下⼏个⽅⾯,从实际⽤法的⾓度进⾏介绍。
Lambda 表达式函数式接⼝Stream默认⽅法Optional 类⼆、Lambda表达式2.1 引例@Data@Builder@NoArgsConstructor@AllArgsConstructorpublic class Product {private String id;private Long num;private Double price;}为了以后排序,我们定义⼀种⽐较器,按价格排序:Comparator<Product> byPrice = new Comparator<Product>() {@Overridepublic int compare(Product o1, Product o2) {return o1.getPrice().compareTo(o2.getPrice());}};byPrice的作⽤是按价格⽐较2种产品,它是⼀种⾏为,可以⽤Lambda表达:Comparator<Product> byPrice = (Product o1, Product o2) -> o1.getPrice().compareTo(o2.getPrice();这⾥只有⼀种类型Product,可根据Comparator<Product>判断,因此进⼀步简化:Comparator<Product> byPrice = (o1, o2) -> o1.getPrice().compareTo(o2.getPrice();2.2 概念Lambda表⽰⼀种⾏为,通过Lambda表达式将⾏为参数化,这样,⾏为可以和对象⼀样传递;从第三章可以了解,Lambda表达式可以⽤函数式接⼝表⽰,Comparator就是⼀种函数式接⼝;2.3 表达式Lambda表达式有三部分,参数列表、"->"、Lambda主体,实际中有以下2种形式:(parameters) -> expression(parameters) ->{ statements; }(List<Product> list) -> list.isEmpty; // 判断队列为空() -> new Product(); // 新建⼀个对象(String s) -> s.length; // 求字符串长度(Product p) -> System.out.println(p); // 输出对象三、函数式接⼝3.1 相关概念函数式接⼝:只定义⼀个抽象⽅法的接⼝;它可能还会有很多默认⽅法,但有且仅有⼀个抽象⽅法;常见的函数式接⼝如Comparator, Runnable;函数式接⼝可以⽤来表达Lamdba表达式;如将⼀个Lamdba表达式传递给⼀个函数式接⼝,即Lamdba表达式以内联的⽅式实现了函数式接⼝;函数描述符:函数式接⼝的抽象⽅法;如果我们想写⼀个⽤于2个数计算的计算器,可能需要实现如下⼏个函数,根据运算符调⽤对应函数计算;public <T> T add(T a, T b);public <T> T add(T a, T b);public <T> T multiply(T a, T b);public <T> T divide(T a, T b);换⼀种思路,如果有这样⼀个函数 public double func(double a, double b, Function f); f是⼀个函数式接⼝,它表⽰具体运算,具体代码实现如下:@Log4j2public class T19 {public static void main(String[] args) {(myFunction(1, 2, (a, b) -> a + b));(myFunction(1.0, 2.0, (a, b) -> a - b));(myFunction(BigDecimal.ZERO, BigDecimal.valueOf(2), (a, b) -> a.multiply(b)));}public static <T> T myFunction(T a, T b, MyBiFunctionInterface<T> f) {return f.apply(a, b);}}@FunctionalInterfacepublic interface MyBiFunctionInterface<T> {T apply(T a, T b);}输出如下:2018-09-01 19:39:11 - test.other.T19 INFO test.other.T19.main(T19.java:20) : 32018-09-01 19:39:11 - test.other.T19 INFO test.other.T19.main(T19.java:21) : -1.02018-09-01 19:39:11 - test.other.T19 INFO test.other.T19.main(T19.java:22) : 0Java8提供了很多函数式接⼝,⼀般情况下不⽤去定义函数式接⼝,⽐如例⼦中MyBiFunctionInterface,可⽤BinaryOperator代替,BinaryOperator这个函数式接⼝,接收2个类型为T的参数,返回⼀个类型为T的结果,即(T, T) -> T,修改后如下:public static <T> T myFunction(T a, T b, BinaryOperator<T> f) {return f.apply(a, b);}3.3 常见函数式接⼝Function<T, R>T-> RPredict<T>T -> booleanConsumer<T>T -> voidSupplier<T>() -> TUnaryOperator<T>T -> TBinaryOperator<T>(T, T) -> TBiFunction<T, U>(T, U) -> RBiPredicate<L, R>(L, R) -> booleanBiConsumer<T, U>(T, U) -> void3.4 ⽅法引⽤Lamdba表达式的快捷写法,它更直观,可读性更好,⽐如:(Product p) -> p.getPrice == Product::getPrice⽅法引⽤主要有⼆类:(1)指向静态⽅法;如 Integer::parseInt;(2)指向实例⽅法:如 String::length;(3)构造函数的⽅法引⽤:如Supplier<Product> p = Product::new;例:第⼆章引例中还可以如下表达:Comparator<Product> c = paring(Product::getPrice);复合,就是将多个Lamdba表达式连接起来,表⽰更加复杂的功能;主要有以下三种(1)函数复合:将Function代表的Lamdba复合起来,有andThen, compose;其中f.andThen(g) = g(f(x)),先计算f表达式,将结果再计算g表达式;pose(g) = f(g(x)),先计算g表达式,将结果再计算f表达式;Function<Integer, Integer> f = x -> x + 1;Function<Integer, Integer> g = x -> x * 2;Function<Integer, Integer> h1 = f.andThen(g); // (1 + 1) * 2 = 4Function<Integer, Integer> h2 = pose(g); // (1 * 2) + 1 = 3(2)Predicate的复合,有negate, and, or,分别表⽰⾮、且、或,按从左到右的顺序Predicate<Product> p1 = a -> a.getPrice() > 100; // ⼤于100Predicate<Product> p2 = p1.negate(); // ⼩于等于100Predicate<Product> p3 = p1.negate().and(a -> a.getNum() > 10); // 价格⼩于等于100,且数量⼤于10(3)⽐较器复合,如Comparator<Product> c = paring(Product::getPrice).reversed().thenComparing(Product::getNum);四、流4.1 概念流⽤来处理数据集合,它具有如下特点:(1)流强调的是计算,它是源+数据处理,流将外部迭代(如for/while)转化为对我们透明的内部迭代;(2)只能遍历⼀次,遍历完就关闭;流具有如下优点:(1)内置了很多常⽤⽅法(如排序、分类、统计);(2)能透明的并⾏处理;(3)声明式的,只需关注我要怎么样,不⽤关注我该如何实现,通过内置的⽅法与复合很容易实现;4.2 流的操作流的操作分为:(1)中间操作:filter(Predicate<T>), map(Function(T, R), limit, sorted(Comparator<T>), distinct,flatMap;(2)终端操作:只有终端操作才能产⽣输出,包括:allMatch, anyMatch, noneMatch, findAny, findFirst, forEach, collect, reduce, count4.3 流的⽤法@Data@Builder@NoArgsConstructor@AllArgsConstructorpublic class Product {private String id;private Long num;private Double price;private Boolean isUse;}List<Product> list = Lists.newArrayList(Product.builder().id("11").num(20l).price(100d).isUse(true).build(),Product.builder().id("12").num(25L).price(120d).isUse(true).build(),Product.builder().id("13").num(25L).price(100d).isUse(true).build(),Product.builder().id("14").num(20L).price(110d).isUse(false).build());(1)filter, 找出价格⼤于100的产品:List<Product> list1 = list.stream().filter(p -> p.getPrice() > 100).collect(Collectors.toList());(2)distinct,去重Arrays.asList(1, 2, 3, 1).stream().distinct().forEach(System.out::print); // 输出123(3)limit,输出前n个Arrays.asList(1, 2, 3, 1).stream().limit(2).forEach(System.out::print); //输出12(4)skip,跳过前n个Arrays.asList(1, 2, 3, 1).stream().skip(2).forEach(System.out::print); // 输出31(5)map, 映射,T -> R<R> Stream<R> map(Function<? super T, ? extends R> mapper);list.stream().map(Product::getPrice).distinct().forEach(System.out::println);输出:100.0120.0110.0(6)flatMap,扁平化,将每个元素产⽣的中间集合合并成⼀个⼤集合;接收的Function将T->Stream<R> <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);Arrays.asList(new String[]{"hello", "world"}).stream().map(p -> p.split("")).flatMap(Arrays::stream) //.flatMap(p -> Arrays.stream(p)).distinct().forEach(System.out::print);// 输出:helowrd(7)匹配boolean anyMatch(Predicate<? super T> predicate);allMatch: 都满⾜条件才返回true;anyMatch: 有⼀个满⾜就返回true;noneMatch: 都不满⾜才返回true;boolean b = Arrays.asList(1, 2, 3, 1).stream().anyMatch(p -> p > 2); //返回true(8)查找,与其它操作结合使⽤findAny: Optional<T> findAny()findFirst: Optional<T> findFirst()Arrays.asList(1, 2, 3, 4, 1).stream().filter(p -> p > 2).findAny() //输出Optional[3]Arrays.asList(1, 2, 3, 4, 1).stream().filter(p -> p > 2).findFirst() //输出Optional[3]4.4 reduce归约归约操作是很常⽤的操作,它将流中的值反复的结合起来,最终得到⼀个值,它是⼀种终端操作;(1)Optional<T> reduce(BinaryOperator<T> accumulator);(2)T reduce(T identity, BinaryOperator<T> accumulator);(3)<U> U reduce(U identity,BiFunction<U, ? super T, U> accumulator,BinaryOperator<U> combiner);(1)给定归约算法,最终归约成⼀个值,考虑到流可能为空,所以返回类型为Option,例:Optional<Integer> op1 = Arrays.asList(1, 2, 3, 4, 1).stream().reduce(Integer::sum); //输出Optional[11](2)给定了初值,归约算法,返回结果;Arrays.asList(1, 2, 3, 4, 1).stream().reduce(0, Integer::sum); //输出11// Steam<T>中T为包装类型,没有sum,但Java8为流的原始类型提供了⼀些⽅法,如下Arrays.asList(1, 2, 3, 4, 1).stream().mapToInt(a -> a).sum();list.stream().mapToLong(Product::getNum).sum();(3)第三个参数表⽰合并⽅式,当是并⾏流时,各线程独⽴计算结果,最后将各线程的结果合并;BiFunction<Double, Product, Double> f1 = (Double a, Product b) -> a + b.getNum();BinaryOperator<Double> f2 = (a, b) -> a + b;double b2 = list.parallelStream().reduce(0d, f1, f2);(b2); //输出904.5 数值流数值流除了具有流的⽅法外,还有⼀些特殊的统计⽅法,例DoubleStream doubleStream = list.stream().mapToDouble(Product::getPrice);double average = doubleStream.average().getAsDouble();//数值流->对象流Stream<Double> sd = doubleStream.boxed();// ⽣成n以内的勾股数Stream<double[]> stream = IntStream.rangeClosed(1, 30).boxed().flatMap(a -> IntStream.rangeClosed(a, 30).mapToObj(b -> new double[]{a, b, Math.sqrt(a * a + b * b)}).filter(t -> t[2] % 1 == 0));stream.limit(3).forEach(t -> System.out.println(t[0] + ", " + t[1] + ", " + t[2]));输出:3.0,4.0,5.05.0, 12.0, 13.06.0, 8.0, 10.04.6 构建流Stream.iterate(0, n -> n + 2).limit(10);Stream.generate(Math::random).limit(10);五、收集器(collect归约)5.1 常见⽤法Map<Double, List<Product>> map = list.stream().collect(groupingBy(Product::getPrice));Long allNum = list.stream().collect(summingLong(Product::getNum));double average = list.stream().collect(averagingDouble(Product::getPrice));LongSummaryStatistics statistics = list.stream().collect(summarizingLong(Product::getNum));String ids = list.stream().map(Product::getId).collect(joining(", "));5.2 reducing归约Optional<Product> opp = list.stream().collect(reducing((a, b) -> a.getPrice() > b.getPrice() ? a : b));long allNum2 = list.stream().collect(reducing(0L, Product::getNum, Long::sum));long allNum3 = list.stream().collect(reducing(0L, Product::getNum, (i, j) -> i + j));collect中reducing归约三要素,初值,提取值,归约⽅法,若⽆初值返回Optional,若提取值即是对象本⾝,可省略;5.3 多重分组Map<Double, Map<Long, List<Product>>> map = list.stream().collect(groupingBy(Product::getPrice, groupingBy(Product::getNum))); Map<Double, Map<String, List<Product>>> map2 = list.stream().collect(groupingBy(Product::getPrice, groupingBy(p -> {if (p.getNum() <= 80L)return "little";else if (p.getNum() >= 120L)return "many";elsereturn "normal";})));System.out.println(JacksonUtil.toJson(map));System.out.println(JacksonUtil.toJson(map2));输出如下:{"100.0" : {"20" : [ {"id" : "11","num" : 20,"price" : 100.0,"isUse" : true} ],"25" : [ {"id" : "13","num" : 25,"price" : 100.0,"isUse" : true} ]},"110.0" : {"20" : [ {"id" : "14","num" : 20,"price" : 110.0,"isUse" : false} ]},"120.0" : {"25" : [ {"id" : "12","num" : 25,"price" : 120.0,"isUse" : true} ]}}{"100.0" : {"little" : [ {"id" : "11","num" : 20,"price" : 100.0,"isUse" : true}, {"id" : "13","num" : 25,"price" : 100.0,"isUse" : true} ]},"110.0" : {"little" : [ {"id" : "14","num" : 20,"price" : 110.0,"isUse" : false} ]},"120.0" : {"little" : [ {"id" : "12","num" : 25,"price" : 120.0,"isUse" : true} ]}}在⼀次分组的⼦集合中处理数据Map<Double, Long> map = list.stream().collect(groupingBy(Product::getPrice, counting()));Map<Double, Optional<Product>> map2 = list.stream().collect(groupingBy(Product::getPrice, maxBy(comparingLong(Product::getNum)))); Comparator<Product> c = ((p1, p2) -> p1.getNum().compareTo(p2.getNum()));Map<Double, Optional<Product>> map3 = list.stream().collect(groupingBy(Product::getPrice, maxBy(c)));Map<Double, Product> map4 = list.stream().collect(groupingBy(Product::getPrice,collectingAndThen(maxBy(comparing(Product::getNum)), Optional::get)));5.4 分区由⼀个谓词作为分类,分为2类,true与false,⽤法与groupingBy完全⼀样Map<Boolean, List<Product>> map = list.stream().collect(partitioningBy(Product::getIsUse));Map<Boolean, Map<Double, List<Product>>> map2 = list.stream().collect(partitioningBy(Product::getIsUse,groupingBy(Product::getPrice)));Map<Boolean, LongSummaryStatistics> map3 = list.stream().collect(partitioningBy(Product::getIsUse,summarizingLong(Product::getNum)));Map<Boolean, Double> map4 = list.stream().collect(partitioningBy(Product::getIsUse, averagingLong(Product::getNum)));六、optional6.1 使⽤(1)单级包装⽤法:我们会见到如下代码,String name = null;if (product != null) {name = product.getId();}利⽤optional可转化为Optional<Product> optProduct = Optional.ofNullable(product);Optional<String> optName = optProduct.map(Product::getId);(2)多级包装⽤法public String getName(Person person) {return person.getCar().getInsurance().getName();}经过包装如下,注意为防⽌Optional<Optional<T>>这种中间结果造成编译不通过,需要使⽤flatMap public String getName(Person person) {Optional<Person> optPerson = Optional.ofNullable(person);return optPerson.flatMap(Person::getCar).flatMap(Car::getInsurance).map(Insurance::getName).orElse("Unknown"); }。
java8使用线程池用法
java8使用线程池用法在Java8中,线程池是一种重要的多线程处理方式,可以有效管理线程资源,提高程序的性能和效率。
本文将介绍Java8中线程池的用法,包括如何创建线程池、提交任务、设置线程池参数等方面。
一、创建线程池在Java8中,可以使用Executors工具类来创建线程池。
Executors提供了一系列工厂方法来创建不同类型的线程池,如newFixedThreadPool、newCachedThreadPool、newSingleThreadExecutor 等。
通过调用这些工厂方法,可以快速地创建不同特性的线程池。
二、提交任务创建线程池之后,可以通过调用submit或execute方法来向线程池提交任务。
submit方法用于提交实现了Callable接口的任务,返回一个Future对象,可以通过该对象获取任务的执行结果。
而execute方法用于提交实现了Runnable接口的任务,无返回结果。
三、设置线程池参数在创建线程池时,可以通过ThreadPoolExecutor构造方法来设置线程池的参数,如核心线程数、最大线程数、存活时间、任务队列等。
通过设置这些参数,可以灵活地控制线程池的行为,实现更好的任务调度和线程资源管理。
四、线程池的执行流程当向线程池提交任务时,线程池会根据任务类型和当前线程池状态进行判断。
若有空闲线程可用,则立即执行任务;若无空闲线程,但未达到最大线程数,则创建新线程执行任务;若任务队列已满,则根据拒绝策略处理任务。
五、线程池的状态管理Java8提供了一系列方法来管理线程池的状态,如shutdown、shutdownNow、isShutdown、isTerminated等。
通过这些方法,可以安全地关闭线程池,避免资源泄露和任务丢失。
总结:通过本文的介绍,我们了解了Java8中线程池的使用方法,包括创建线程池、提交任务、设置参数、执行流程和状态管理等方面。
合理地使用线程池可以提高程序的性能和效率,避免线程频繁创建和销毁带来的开销,推荐在多线程编程中使用线程池来管理线程资源。
java常用类及使用方法
java常用类及使用方法Java是一种面向对象的编程语言,拥有许多常用的类和方法,这些类和方法可以帮助开发人员更轻松地完成各种任务。
以下是一些常用类及其使用方法的概述。
1. String类:String类用于处理字符串,提供了许多常用的字符串操作方法,例如拼接字符串、截取子串、查找字符等。
可以使用String类的构造函数创建一个字符串对象,然后使用该对象调用各种方法进行字符串处理。
2. Math类:Math类提供了许多数学运算的静态方法,例如求绝对值、求平方根、取整等。
可以直接通过类名调用这些方法,而不需要创建Math类的对象。
3. Scanner类:Scanner类用于从控制台或其他输入流中读取用户的输入。
可以使用Scanner类的构造函数创建一个Scanner对象,然后使用该对象调用各种方法来获取用户输入的数据。
4. ArrayList类:ArrayList类是Java集合框架中的一部分,它实现了可变长度的数组。
可以使用ArrayList类来存储和操作一组对象。
可以使用ArrayList 类的构造函数创建一个ArrayList对象,并使用add()方法向其中添加元素,使用get()方法获取指定位置的元素,使用remove()方法删除指定位置的元素等。
5. Date类:Date类用于表示日期和时间。
可以使用Date类的构造函数创建一个Date对象,然后使用该对象调用各种方法来获取和操作日期和时间的信息。
6. File类:File类用于表示文件和目录的路径。
可以使用File类的构造函数创建一个File对象,然后使用该对象调用各种方法来操作文件和目录,例如创建文件、删除文件、重命名文件等。
以上只是一些常用类的简要介绍,实际上Java还有许多其他常用类,如HashMap、HashSet、FileReader、BufferedReader等。
开发人员可以根据自己的需求,选择合适的类来完成任务。
在使用这些类时,可以参考Java官方文档或其他相关的学习资源,了解类的详细使用方法和注意事项。
java的八个基本类型
java的八个基本类型
Java 是一种面向对象的编程语言,它支持八个基本数据类型,分别是 byte、short、int、long、float、double、char 和 boolean。
下面我们将详细介绍这些类型。
1. byte(字节型)
byte 类型用于存储整型数值(-128 到 127),占用一个字节的空间。
byte 类型通常用于处理文件、网络数据和图像等二进制数据。
3. int(整型)
int 类型用于存储整型数值(-2147483648 到 2147483647),占用四个字节的空间。
int 类型是 Java 中最常用的整型类型,可以用于保存整数、枚举和数组下标等数据。
5. float(单精度浮点型)
float 类型用于存储浮点数值,占用四个字节的空间,在数值范围和精度上比
double 类型差。
float 类型通常用于科学计算和图形处理等领域。
7. char(字符型)
char 类型用于存储 Unicode 字符,占用两个字节的空间。
char 类型可以表示所有
的字符和符号,包括汉字和 Emoji 等表情符号。
8. boolean(布尔型)
boolean 类型只有两个取值,true 和 false。
boolean 类型通常用于控制流程和逻
辑处理等场景。
在 Java 中,基本数据类型属于值类型,它们的值存储在变量的内存空间中。
如果你
想修改变量的值,需要重新赋值。
这与引用类型不同,引用类型保存的是指向对象的指
针。
java8 常用的方法汇总
java8 常用的方法汇总Java 8是一个非常重要的版本,引入了许多新的功能和改进,为开发人员提供了更好的工具和方法。
本文将总结Java 8中一些常用的方法,帮助读者更好地了解和使用这些功能。
1. Lambda表达式:Lambda表达式是Java 8引入的最重要的特性之一。
它可以用更简洁的语法实现函数式编程,使代码更加简洁和可读。
Lambda表达式可以用于替代匿名内部类的写法,从而使代码更加简洁。
2. Stream API:Stream API是Java 8中另一个重要的特性,它提供了一种新的处理集合的方式。
使用Stream API,可以更方便地对集合进行过滤、映射、排序和聚合等操作,使代码更加简洁和易于理解。
3. 方法引用:方法引用是Java 8中的另一个重要特性,它提供了一种更简洁的方式来引用已经存在的方法。
使用方法引用,可以将一个方法作为参数传递给另一个方法,使代码更加简洁和易于理解。
4. Optional类:Optional类是Java 8引入的一个新的类,用于解决空指针异常的问题。
使用Optional类,可以更好地处理可能为空的对象,避免空指针异常的发生。
5. 接口的默认方法:Java 8允许在接口中定义默认方法,这些方法可以有默认的实现。
这样一来,当接口的实现类没有实现默认方法时,会自动使用接口中定义的默认实现。
这样可以更方便地向已有的接口中添加新的方法,而不会破坏已有的实现。
6. 新的日期和时间API:Java 8引入了一个新的日期和时间API,用于替代旧的Date和Calendar类。
新的日期和时间API提供了更方便的日期和时间处理方式,使代码更加可读和易于维护。
7. CompletableFuture类:CompletableFuture类是Java 8中新增的一个类,用于实现异步编程。
使用CompletableFuture类,可以更方便地处理异步任务的结果,提高程序的性能和响应速度。
java8 常用的方法汇总
java8 常用的方法汇总Java 8是Java语言的一个重要版本,引入了许多新的特性和改进。
在这篇文章中,我们将对Java 8中一些常用的方法进行汇总和介绍。
这些方法包括Lambda表达式、函数式接口、Stream流、Optional 类、方法引用、默认方法等。
1. Lambda表达式Lambda表达式是Java 8中最重要的特性之一。
它提供了一种更简洁、更高效的方式来实现函数式编程。
Lambda表达式可以替代匿名内部类,使代码更加简洁易读。
例如:```List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); numbers.forEach(n -> System.out.println(n));```2. 函数式接口函数式接口是Java 8中引入的一个新的接口类型。
它只包含一个抽象方法,可以用Lambda表达式来实现。
Java 8为函数式接口引入了一个新的注解@FunctionalInterface,用于标记函数式接口。
例如:```@FunctionalInterfaceinterface MyInterface {void myMethod();}```3. Stream流Stream是Java 8中新增的一个处理集合数据的API。
它提供了一种流式操作的方式,可以对集合进行过滤、映射、排序等操作。
Stream可以大大简化集合的处理,并且可以实现并行操作提高性能。
例如:```List<String> list = Arrays.asList("apple", "banana", "orange");list.stream().filter(s -> s.startsWith("a")).map(String::toUpperCase).forEach(System.out::println);```4. Optional类Optional是Java 8中新增的一个类,用于处理可能为空的值。
java_8_-_类型注解的用法_概述及解释说明
java 8 - 类型注解的用法概述及解释说明1. 引言1.1 概述引言部分将介绍本文的主题和背景,即Java 8中类型注解的用法。
我们将从概念上对类型注解进行简要概括,并说明它在Java编程中的重要性和应用价值。
1.2 文章结构在本节中,我们将简要介绍文章的结构,以便读者可以了解整篇文章的内容和组织方式。
本文共包含5个主要部分,分别是引言、类型注解的用法、示例和应用场景、与传统注解的对比分析以及结论与展望。
1.3 目的在这一小节中,我们将给出撰写本文的目的。
通过阅读本文,读者将能够全面了解Java 8中类型注解的定义、语法和使用方式,并了解其与传统注解之间的区别和优势。
我们还将提供一些实际示例和应用场景,以帮助读者更好地理解并应用类型注解。
最后,在结论部分,我们将总结本文所讨论的核心要点,并展望未来类型注解在Java开发中可能发展及应用的方向。
以上是“1. 引言”部分内容,请根据需要进行适当调整或添加详细信息。
2. 类型注解的用法2.1 什么是类型注解类型注解是Java 8中引入的一项新特性,它允许我们在代码编写过程中对变量、参数、方法返回值等进行更加精确的类型约束。
通过使用类型注解,我们可以在编译时对代码进行静态检查,以减少潜在的错误和异常。
2.2 类型注解的作用类型注解主要有以下几个作用:- 提供更加丰富和准确的编译时类型检查。
通过使用类型注解,我们可以为变量、参数、方法返回值等添加具体的含义和限制条件,从而增强代码可读性并减少运行时错误。
- 改善API文档生成。
类型注解可以提供更加明确和详细的信息,使得API文档更容易理解和使用。
- 为IDE工具提供更好的支持。
许多集成开发环境(IDE)已经开始支持Java 8中新增的类型注解功能,并提供相应的代码提示和错误检查功能,帮助开发人员处理潜在的问题。
2.3 类型注解的语法和用法在Java 8中,我们可以通过给变量、参数、方法返回值等添加相关注释来使用类型注解。
JAVA常用类的使用方法
JAVA常用类的使用方法Java中的常用类有很多,以下是其中一些常见的类及其使用方法:1. String类:用于处理字符串。
常用方法有:- indexOf(String str):返回指定字符串在当前字符串中第一次出现的索引。
- length(:返回字符串的长度。
- charAt(int index):返回指定索引处的字符。
- toUpperCase(:将字符串转换为大写形式。
- toLowerCase(:将字符串转换为小写形式。
2. StringBuilder类:用于处理可变的字符串。
常用方法有:- append(String str):将指定字符串追加到当前字符串的末尾。
- insert(int offset, String str):在指定位置插入字符串。
- delete(int start, int end):删除指定位置的字符。
- reverse(:将字符串反转。
3. Math类:提供了一些数学运算相关的方法。
常用方法有:- abs(int a):返回指定整数的绝对值。
- pow(double a, double b):返回a的b次幂。
- sqrt(double a):返回指定double值的平方根。
- random(:返回一个随机数(0 ~ 1之间)。
- ceil(double a):返回大于等于指定double值的最小整数。
4. ArrayList类:实现了动态数组,用于存储对象。
常用方法有:- add(E e):将指定元素添加到列表的末尾。
- get(int index):返回列表中指定位置的元素。
- remove(int index):删除列表中指定位置的元素。
- size(:返回列表中元素的数量。
- contains(Object o):判断列表是否包含指定元素。
5. HashMap类:用于存储键值对。
常用方法有:- put(K key, V value):将指定的键值对添加到Map中。
八大基本数据类型的默认值
八大基本数据类型的默认值1. 引言1.1 什么是八大基本数据类型八大基本数据类型是编程语言中最基本的数据类型,用于存储不同种类的数据。
在Java中,八大基本数据类型包括整型数据类型(byte、short、int、long)、浮点型数据类型(float、double)、字符型数据类型(char)以及布尔型数据类型(boolean)。
这些数据类型在程序中被广泛应用,每种数据类型都有其特定的取值范围和默认值。
了解八大基本数据类型的默认值对于编程非常重要,因为在定义变量时如果没有为其赋值,变量会自动初始化为其默认值。
如果程序员不了解默认值,可能会导致程序出现意外的错误或bug,所以掌握八大基本数据类型的默认值是编程的基本要求。
除了默认值,了解每种数据类型的取值范围也是非常重要的。
在程序设计过程中,我们需要根据数据的具体需求选择合适的数据类型,避免数据溢出或精度丢失的情况发生。
通过深入了解八大基本数据类型及其默认值,可以更好地进行程序设计和优化,提高代码的质量和效率。
1.2 为什么需要了解默认值了解八大基本数据类型的默认值对于程序员来说是非常重要的。
在编程过程中,我们经常需要声明变量并给其赋初值,而了解默认值可以帮助我们更加高效地编写代码。
了解默认值可以避免程序出现意外的错误。
如果我们没有显式地为变量赋值,那么系统会为其赋予默认值。
如果我们不了解这些默认值,就有可能在使用这些变量时出现逻辑错误,影响程序的运行结果。
了解默认值可以让我们更好地利用变量。
有些变量在不同的数据类型下会有不同的默认值,比如在整型数据类型下,int类型的默认值为0,而在布尔型数据类型下,boolean类型的默认值为false。
如果我们了解这些默认值,就能更好地利用这些变量,提高代码的可读性和可维护性。
2. 正文2.1 整型数据类型的默认值整型数据类型是编程中经常使用的一种基本数据类型,用于存储整数值。
在大多数编程语言中,整型数据类型的默认值为0。
java用法总结归纳
java用法总结归纳Java是一种面向对象的编程语言,被广泛应用于各种开发领域。
本文将对Java的常用用法进行总结归纳,包括基本语法、数据类型、控制语句、函数和异常处理等方面。
一、基本语法1. 注释在Java中,可以使用双斜线(//)进行单行注释,也可以使用/* ...*/进行多行注释。
注释是对代码进行解释和说明的关键工具,可以提高代码的可读性。
2. 数据类型Java提供了多种数据类型,包括整型(int、long)、浮点型(float、double)、字符型(char)、布尔型(boolean)等。
在进行变量声明时,需要指定变量的数据类型,例如:int num = 10;3. 变量与常量声明变量时,可以使用关键字"var"进行类型推断,例如:var name= "John";常量使用关键字"final"修饰,一旦被赋值后,其数值将不可再更改。
4. 运算符Java支持常见的算术运算符(+、-、*、/、%)、关系运算符(>、<、==、!=)和逻辑运算符(&&、||、!)等。
了解运算符的优先级和结合性可以帮助编写更加精确的代码。
二、数据类型1. 字符串Java中的字符串使用String类表示,可以使用"+"进行字符串连接操作,例如:String fullName = firstName + lastName;还可以使用String的方法,如length()获取字符串长度,charAt(i)获取第i个字符等。
2. 数组数组是一种存储相同类型数据的容器,使用方括号"[]"来声明和访问数组。
例如:int[] numbers = {1, 2, 3, 4, 5};可以使用循环结构和索引来遍历数组,并对数组元素进行操作。
三、控制语句1. 条件语句Java提供了if语句、switch语句等来实现条件判断和分支控制。
JAVA常用类的使用方法
JAVA常用类的使用方法1. String类:String类是ng包下常用的类,用于操作字符串。
以下是一些常用的String类的方法:- length(方法:返回字符串的长度。
- charAt(int index)方法:返回字符串指定位置的字符。
- substring(int beginIndex)方法:返回从指定位置开始到字符串末尾的子字符串。
- substring(int beginIndex, int endIndex)方法:返回指定范围内的子字符串。
- equals(Object obj)方法:比较两个字符串是否相等。
- indexOf(String str)方法:返回指定子字符串在字符串中第一次出现的位置。
- toLowerCase(方法:将字符串转换为小写字母。
- toUpperCase(方法:将字符串转换为大写字母。
- replace(char oldChar, char newChar)方法:将字符串中的指定字符替换为新字符。
- split(String regex)方法:使用正则表达式将字符串分割为子字符串数组。
2. StringBuilder和StringBuffer类:StringBuilder和StringBuffer类是ng包下用于操作字符串的可变字符序列类。
以下是一些常用的方法:- append(String str)方法:在字符串末尾追加指定字符串。
- insert(int offset, String str)方法:在指定位置插入字符串。
- delete(int start, int end)方法:删除指定范围内的字符。
- replace(int start, int end, String str)方法:替换指定范围内的字符为指定字符串。
- reverse(方法:翻转字符串。
3. Math类:Math类是ng包下用于执行数学操作的类。
以下是一些常用方法:- abs(int a)方法:返回指定整数的绝对值。
java8 使用技巧
java8 使用技巧Java 8是Java语言的一个重要版本,引入了Lambda表达式和Stream API等新特性,使得Java在函数式编程和流处理方面更加灵活和强大。
以下是一些Java 8的使用技巧:1. Lambda表达式:Lambda表达式是Java 8中引入的一种新特性,它使得编写简洁、功能强大的代码更加容易。
Lambda表达式可以用于实现函数式接口,从而实现代码的模块化和复用。
2. Stream API:Stream API是Java 8中用于处理集合的一个强大工具。
通过Stream API,你可以轻松地对集合进行各种操作,如过滤、映射、排序等。
Stream API还支持并行处理,使得处理大规模数据更加高效。
3. Optional 类型:Optional 类型是Java 8中引入的一个新类型,用于解决空指针异常的问题。
通过使用Optional 类型,你可以更加清晰地表达一个值可能存在也可能不存在,从而减少代码中的空指针异常。
4. 方法引用:方法引用是Java 8中引入的另一个新特性,它使得编写简洁、易读的代码更加容易。
方法引用允许你将一个方法作为参数传递给另一个方法,或者将一个方法作为Lambda表达式的主体。
5. 使用Predicate和Function:Predicate和Function是Java 8中的两种函数式接口,它们分别用于表示谓词(判断条件)和函数(计算规则)。
通过使用Predicate和Function,你可以更加灵活地编写条件判断和数据处理逻辑。
6. 自定义函数式接口:除了Java提供的函数式接口,你还可以自定义函数式接口。
通过自定义函数式接口,你可以将特定的业务逻辑抽象出来,并在需要时重复使用。
7. 使用JavaFX进行GUI开发:JavaFX是Java的一个GUI工具包,它提供了丰富的组件和API,使得开发富客户端应用程序更加容易。
通过使用JavaFX,你可以创建出美观、功能强大的GUI应用程序。
Java8常用方法总结
Java8常⽤⽅法总结Java8 使⽤ stream().map()提取List对象的某⼀列值及排重List对象类(StudentInfo)@Data@Builder@AllArgsConstructor@RequiredArgsConstructorpublic class StudentInfo implements Comparable<StudentInfo> {//名称private String name;//性别 true男 false⼥private Boolean gender;//年龄private Integer age;//⾝⾼private Double height;//出⽣⽇期private LocalDate birthday;}测试数据//测试数据,请不要纠结数据的严谨性List<StudentInfo> studentList = new ArrayList<>();studentList.add(new StudentInfo("李⼩明",true,18,1.76,LocalDate.of(2001,3,23)));studentList.add(new StudentInfo("张⼩丽",false,18,1.61,LocalDate.of(2001,6,3)));studentList.add(new StudentInfo("王⼤朋",true,19,1.82,LocalDate.of(2000,3,11)));studentList.add(new StudentInfo("陈⼩跑",false,17,1.67,LocalDate.of(2002,10,18)));提取某⼀列(以name为例)//从对象列表中提取⼀列(以name为例)List<String> nameList = studentList.stream().map(StudentInfo::getName).collect(Collectors.toList());提取age列并排重(使⽤distinct()函数)//从对象列表中提取age并排重List<Integer> ageList = studentList.stream().map(StudentInfo::getAge).distinct().collect(Collectors.toList());Java8 使⽤ stream().sorted()对List集合进⾏排序集合对像定义集合对象以学⽣类(StudentInfo)为例,有学⽣的基本信息,包括:姓名,性别,年龄,⾝⾼,⽣⽇⼏项。
java8 泛型 lambda表达式用法
文章标题:深度剖析Java 8中泛型与Lambda表达式的妙用在Java编程语言中,泛型和Lambda表达式是非常重要的概念和特性。
它们的引入使得Java语言更具灵活性和功能性,也让程序员们能够以更简洁的方式编写代码。
在本文中,我们将深入探讨Java 8中泛型和Lambda表达式的用法,并读者能够更深入地理解这两个概念。
1. 泛型的概念与用法在Java编程中,泛型是一种参数化类型的概念,它使得数据类型可以在使用的时候才确定。
泛型的引入大大提高了代码的复用性,并在编译时提供了类型安全检查。
在Java 8中,泛型的语法得到了进一步的优化和拓展,使得泛型的使用更加方便和灵活。
2. Java 8中泛型的新特性在Java 8中,泛型方面有了许多新特性,比如类型推断、泛型方法、通配符和上下界等。
这些新特性大大拓展了泛型的使用范围和灵活性,在我们的日常编程中能够更加方便地利用泛型来解决问题。
3. Lambda表达式的概念与用法Lambda表达式是Java 8中引入的一个重要特性,它使得我们能够以更简洁和清晰的方式来表达匿名函数。
Lambda表达式的引入大大简化了代码的编写,并使得函数式编程在Java中能够得到更好的支持。
4. Java 8中Lambda表达式的新特性在Java 8中,Lambda表达式也得到了许多新特性的拓展和优化,比如方法引用、构造方法引用、lambda作用域和闭包等。
这些新特性赋予了Lambda表达式更强大的表达能力和灵活性,在很多场景中都能够发挥出更好的效果。
5. 对Java 8中泛型与Lambda表达式的个人看法泛型和Lambda表达式作为Java 8中的重要特性,它们的引入为我们带来了很多便利和好处。
泛型使得代码更具有通用性和安全性,而Lambda表达式则使得函数式编程的风格更容易在Java中实现。
作为一名Java程序员,我个人认为深入理解和掌握这两个特性是非常重要的,它们不仅能够让我们写出更加高质量和简洁的代码,也能够让我们更好地适应和利用Java 8以后的新特性。
八大基本数据类型java
八大基本数据类型java
Java中有八种基本数据类型,分别是整型、浮点型、字符型、布尔型和四种派生类型。
整型包括byte、short、int和long四种,分别占用1、2、4和8个字节。
浮点型包括float和double两种,分别占用4和8个字节。
字符型char占用2个字节。
布尔型boolean 只占用1个字节,但只能取true或false两个值。
四种派生类型包括字符串(String)、枚举(Enum)、数组(Array)和类(Class)。
这八种基本数据类型在Java中都有其对应的数据范围,要根据具体的业务需求选择相应的数据类型。
整型数据类型可以存储整数类型的数据,浮点型数据类型可以存储浮点数类型的数据,字符型数据类型可以存储字符类型的数据,布尔型数据类型可以存储布尔类型的数据。
在Java程序中,我们可以使用基本数据类型来定义变量,并对其进行赋值操作。
同时,我们还可以使用强制类型转换来将一个数据类型转换为另一个数据类型。
基本数据类型还有一些常见的运算符,如算术运算符、关系运算符、逻辑运算符、位运算符等,这些运算符可以帮助我们进行各种数值计算和逻辑判断操作。
总之,八大基本数据类型是Java编程中非常重要的概念,掌握好它们的使用方法,对于我们编写高质量的Java程序有着至关重要的作用。
- 1 -。
java8 泛型 lambda表达式用法
java8 泛型 lambda表达式用法(最新版)目录一、Java 8 泛型的概念与应用1.泛型的定义与作用2.泛型与继承的关系3.泛型与多态的实现二、Lambda 表达式的概述mbda 表达式的概念mbda 表达式的特点mbda 表达式与匿名类的区别三、Java 8 Lambda 表达式在泛型中的使用mbda 表达式与泛型的结合mbda 表达式在泛型中的优势mbda 表达式在泛型中的示例正文一、Java 8 泛型的概念与应用Java 8 是一个具有里程碑意义的版本,它引入了许多新特性,其中之一就是泛型。
泛型是一种编程语言结构,允许我们编写可以适用于不同类型的代码,从而提高代码的可重用性和灵活性。
在 Java 8 中,泛型的概念与应用得到了进一步加强。
1.泛型的定义与作用泛型是一种抽象类型,它允许我们定义一组具有相同方法签名的类,而无需考虑它们的实际类型。
泛型的主要作用是限制类型,使得编译器可以检查类型安全,从而避免运行时出现类型转换错误。
2.泛型与继承的关系在 Java 8 中,泛型类可以继承非泛型类,也可以实现泛型接口。
通过泛型,我们可以在编译时检查类型安全,避免运行时出现类型转换错误。
此外,泛型还可以提高代码的可读性和可维护性。
3.泛型与多态的实现泛型在 Java 8 中得到了进一步加强,可以实现多态。
通过泛型,我们可以创建不同类型的对象,并实现相同的方法。
这大大提高了代码的可重用性和灵活性。
二、Lambda 表达式的概述Lambda 表达式是 Java 8 中引入的一种新的表达式,它允许我们以更简洁的方式表示匿名函数。
Lambda 表达式可以出现在任何需要函数的地方,例如作为方法参数、作为集合的元素等。
mbda 表达式的概念Lambda 表达式是一个参数列表和一个方法主体的组合,它们之间用箭头(->)分隔。
例如:(p, q) -> p + q。
mbda 表达式的特点Lambda 表达式具有以下特点:- 语法简洁:Lambda 表达式可以替代匿名类,使代码更简洁易读。
JAVA的八种基本数据类型
JAVA基本数据的八种类型在学习JAVA的时候,我们最先应该了解的是JAVA有哪些数据类型,那么下面就介绍下JAVA的八种数据类型。
一、整数类型——shortshort型即短整型,使用short关键字来定义short型变量,可以一次定义多个变量并对其进行赋值,也可以不进行赋值。
系统给short型分配2个字节的内存,取值范围也比byte型大了很多,在-32768和32767之间,虽然取值范围变大,但是还是要注意数据溢出。
二、整数类型——byte使用byte关键字来定义byte型变量,可以一次定义多个变量并对其进行赋值,也可以不进行赋值。
byte型是整型中所分配的内存空间是最少的,只分配1个字节;取值范围也是最小的,只在-128和127之间,在使用时一定要注意,以免数据溢出产生错误。
三、整数类型——longlong型即长整型,使用long关键字来定义long型变量,可以一次定义多个变量并对其进行赋值,也可以不进行赋值。
而在对long型变量赋值时结尾必须加上“L”或者“l”,否则将不被认为是long型。
当数值过大,超出int型范围的时候就使用long型,系统分配给long型变量8个字节,取值范围则更大,在-9223372036854775808和9223372036854775807之间。
四、浮点类型——floatfloat型即单精度浮点型,使用float关键字来定义float 型变量,可以一次定义多个变量并对其进行赋值,也可以不进行赋值。
在对float型进行赋值的时候在结尾必须添加“F”或者“f”,如果不加,系统自动将其定义为double型变量。
float型变量的取值范围在1.4E-45和3.4028235E-38之间。
五、浮点类型——doubledouble型即双精度浮点型,使用double关键字来定义double型变量,可以一次定义多个变量并对其进行赋值,也可以不进行赋值。
在给double型赋值时,可以使用后缀“D”或“d”明确表明这是一个double类型数据,但加不加并没有硬性规定,可以加也可以不加。
java的八个基本类型
java的八个基本类型Java是一种面向对象的编程语言,它支持八种基本数据类型,包括四种整型、两种浮点型、一种字符型和一种布尔型。
这些基本数据类型在Java中非常重要,因为它们是Java程序中最基本的数据类型,也是Java程序中最常用的数据类型之一。
整型Java中的整型包括四种类型:byte、short、int和long。
这些类型的区别在于它们所占用的内存空间大小不同。
byte类型占用1个字节,short类型占用2个字节,int类型占用4个字节,long类型占用8个字节。
这些类型可以用来存储整数值,例如年龄、身高、体重等。
浮点型Java中的浮点型包括两种类型:float和double。
这些类型可以用来存储小数值,例如温度、速度、重量等。
float类型占用4个字节,double类型占用8个字节。
double类型比float类型更精确,因此在需要高精度计算时,应该使用double类型。
字符型Java中的字符型只有一种类型:char。
char类型占用2个字节,可以用来存储单个字符,例如字母、数字、符号等。
在Java中,char类型的值必须用单引号括起来,例如'c'、'A'、'1'等。
布尔型Java中的布尔型只有一种类型:boolean。
boolean类型只有两个值:true和false。
这些值可以用来表示某个条件是否成立,例如是否登录成功、是否购买成功等。
在Java中,boolean类型的值可以用来控制程序的流程,例如if语句、while语句等。
总结Java中的八种基本数据类型是Java程序中最基本的数据类型,也是Java程序中最常用的数据类型之一。
这些类型可以用来存储整数值、小数值、单个字符和布尔值。
在Java中,我们可以使用这些类型来定义变量、存储数据、进行计算等。
因此,熟练掌握这些基本数据类型是Java程序员的基本功之一。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
Float(double value) :以 double 类型为参数构造 Float 对象。 Float(float value) :以 Float 类型为参数构造 Float 对象。 Float(String s) :以 String 类型为参数构造 Float 对象。
3、方法。
说明: 1. 所有方法均为 public; 2. 书写格式:[修饰符] <返回类型> <方法名([参数列表])> 如: static int parseInt(String s) 表示:此方法(parseInt)为类方法(static),返回类型为(i nt),方法所需参数为 String 类型。
JAVA 常用8种类的使用方法详解: 1、Integer 类 2、Float 类 3、Double 类 4、Character 类 5、String 类 6、StringTokenizer 类 7、StringBuffer 类 8、Random 类
××××××××××××××××××××××××××××××××××××××××××××××××××
2、构造函数。
Integer(int value) :通过一个 int 的类型构造对象; Integer(String s) :通过一个 String 的类型构造对象;
例子:
Integer i = new Integer("1234");生成了一个值为1234的 Integer 对象。
3、方法。 说明: 1. 所有方法均为 public; 2. 书写格式:[修饰符] <返回类型> <方法名([参数列表])> 如: static int parseInt(String s) 表示:此方法(parseInt)为类方法(static),返回类型为(i
3. int compareTo(Object o) :将该整数与其他类进行比较。如果 o 也为 Integer 类,进行 方法2 的操作;否则,抛出 ClassCastException 异常。 4. static Integer decode(String nm) :将字符串转换为整数。 5. double doubleValue() :取得该整数的双精度表示。 6. boolean equals(Object obj) :比较两个对象。 7. float floatValue() :取得该整数的浮点数表示。 8. static Integer getInteger(String nm) :根据指定名确定系统特征值。 9. static Integer getInteger(String nm, int val) :上面的重载。 10. static Integer getInteger(String nm, Integer val) :上面的重载。 11. int hashCode() :返回该整数类型的哈希表码。 12. int intValue() : 返回该整型数所表示的整数。 13. long longValue() :返回该整型数所表示的长整数。 14. static int parseInt(String s) :将字符串转换成整数。s 必须是时进制数组成,否则抛 出 NumberFormatException 异常。 15. static int parseInt(String s, int radix) :以 radix 为基数 radix 返回 s 的十进制数。所 谓的基数,就是“几进制”。
二、Float:实数类型
1、属性。
1. static float MAX_VALUE : 返回最大浮点数,在不同硬件平台中由 Float.intBitsToFlo at(0x7f7fffff)计算得出。 2. static float MIN_VALUE : 返回最小浮点数,在不同硬件平台中由 Float.intBitsToFloa t(0x1)计算得出。 3. static float NaN : 表示非数值类型的浮点数,在不同硬件平台中由 Float.intBitsToFlo at(0x7fc00000)计算得出。 4. static float NEGATIVE_INFINITY:返回负无穷浮点数,在不同硬件平台中由 Float.int BitsToFloat(0xff800000)计算得出。 5. static float POSITIVE_INFINITY :返回正无穷浮点数,在不同硬件平台中由 Float.int BitsToFloat(0x7f800000)计算得出。 6. static Class TYPE :返回当前类型。
例子:
String s1 = new String("1010");System.out.println("Integer.parseInt(String s, int radix): " + Integer.parseInt(s1,2) );结果为:Integer.parseInt(String s, int radix): 10
21. static String toString(int i) :将该整数类型转换为字符串。不同的是,此为类方法。 22. static String toString(int i, int radix) :将整数 i 以基数 radix 的形式转换成字符串。
例子:
int i1 = 54321;System.out.println("Integer.toString(int i, int radix): " + Integer.toString(i 1,16) );结果为:Integer.toString(int i, int radix): d431
Float f = new Float(1237.45); System.out.println("f.equals(fs): " + f.equals(fs) ); 结果为:f.equals(fs): false
××××××××××××××××××××××××××××××××××××××××××××××××××
1. byte byteValue() :返回以字节表示的浮点数。 2. static int compare(float f1, float f2) :此为类方法,比较 f1和 f2。相当于 new Float(f 1).compareTo(new Float(f2))。如果 f1与 f2相等,返回0;小于关系,返回负数;大于关系, 返回正数。 3. int compareTo(Float anotherFloat) :此为对象方法,当前对象与 anotherFloat 比较。 与2的比较规则相同。 4. int compareTo(Object o) :当前对象与 o 进行比较,如果 o 属于 Float 类,那么,相当 于3;如果是其他类,则抛出 ClassCastException 异常。 5. double doubleValue() :返回浮点数的双精度值。 6. boolean equals(Object obj) :比较当前 Float 对象与 obj 的内容是否相同。大多数情况 是比较两个 Float 对象的值是否相等,相当于 f1.floatValue() == f2.floatValue()的值。与2、 3、4不同的是:6返回 boolean 型。 7. static int floatToIntBits(float value):按照 IEEE 754转化成 float 并输出它的十进制数 值。 8. float floatValue() :返回该浮点数对象的浮点数值。 9. int hashCode() :返回该 Float 对象的哈希表码。 10. int intValue() :返回该 Float 对象的整数值(整数部分)。 11. boolean isInfinite() :判断该 Float 对象是否是无穷。 12. static boolean isInfinite(float v) :与11类似,不同的是:此为类方法,判断的是 v。 13. boolean isNaN() :判断该 Float 对象是否为非数值。 14. static boolean isNaN(float v) :功能与13一样,只不过判断 v。 15. long longValue() :返回该 Float 对象的长整数值。 16. static float parseFloat(String s) :将字符串转换成浮点数。 17. short shortValue() :返回该 Float 对象的短整数值。 18. String toString() :将该 Float 对象转换成字符串。 19. static String toString(float f) :功能与18一样,只是转换 f。 20. static Float valueOf(String s) :将字符串转换成浮点数。
一、Interger:整数类型
1、属性。
static int MAX_VALUE:返回最大的整型数; static int MIN_VALUE:返回最小的整型数; static Class TYPE :返回当前类型。
例子:
System.out.println("Integer.MAX_VALUE: " + Integer.MAX_VALUE );结果为:Integer.MA X_VALUE: 2147483647
23. static Integer valueO4. static Integer valueOf(String s, int radix) :将字符串以基数 radix 的要求转换成整数 类型。
××××××××××××××××××××××××××××××××××××××××××××××××××
System.out.println("pareTo(fd): " + pareTo(fd) ); System.out.println("pare(1.23f,3.25f): " + pare(1.23f,3.25f) ); 结果为:pare(fs): pareTo(fd): pare(1.23f,3.25f): -1