java安装_在Java中添加范围类型

最新推荐文章于 2024-07-19 16:36:18 发布

cunfen6312

最新推荐文章于 2024-07-19 16:36:18 发布

阅读量215

点赞数

文章标签：编程语言 python java 大数据 mysql

原文链接：https://www.javacodegeeks.com/adding-range-type-in-java.html

版权

java安装

1.简介

现代和最近的编程语言都具有范围类型的概念。诸如Python，Ada，Ruby和Rust之类的编程语言都具有范围的概念-范围是数字序列或整数序列的有界起点和终点。

Java编程语言因其本身就是冗长，冗长的编程语言而享誉盛名[Pras 2012]。但是，Java语言中没有范围类型。这是Java语言的缺陷，但是使用现有的Java语言功能，范围类型很容易添加到编程语言中。

1.1 Python程式设计语言

Python编程语言[PYna 2020]中的范围示例是：

#!/usr/bin/env python
#
range0to9 = range(0, 10)

for n in range0to9: 
  print(n)

for n in range(0,10): 
  print(n)

1.2 Ada编程语言

Ada编程语言[Wiki 2017]中的范围示例是：

with Ada.Text_IO; use Ada.Text_IO;

procedure Main is
  type Index0to9 is range 0..9;
  package Index_IO is new Integer_IO (Index0to9);

begin

  for I in 0..9 loop
    Put(Integer'Image (I));
    New_Line; 
  end loop;

  for I in Index0to9 loop 
    Index_IO.Put(I); 
    New_Line;
  end loop; 

end Main;

1.3 Rust编程语言

作为一种较新的，讨论最多的编程语言，Rust具有范围类型。考虑以下内容的改编后的Rust源代码[Mozi 2019]：

fn main() {
  for number in 1..10 {
    println!("{}", number); 
  }
}

1.4 Ruby编程语言

Ruby [Ruby 2020]编程语言中使用范围的示例是：

#
#!/usr/bin/ruby
#
range0to9 = 0..9

for i in range0to9 do 
  puts i
end

puts "\n"

for i in 0..9 do 
  puts i
end

puts "\n"

val = 7

if (0..9) === val 
  puts "In the range"
else
  puts "Out of range"
end

puts "\n"

if range0to9.include?(val) 
  puts "In the range"
else
  puts "Out of range"
end

1.5范围类型的优点

这四个示例都做同样的事情，并说明了每种编程语言中范围类型的语法。与作为古老语法形式的替代方案相比，编程语言中范围的优点是更加紧凑，并且在表达性方面更加简洁。如果没有范围类型，则编程语言在编写功能时可能更加冗长，但范围类型功能的表达方式不够清晰。

2. Java的范围类型

可以通过两种方式为Java添加范围类型：

使用非标准的语法和关键字扩展Java语言。
将Java语言与类和功能一起使用以添加功能。

2.1扩展Java语言

添加范围类型的一种方法是将其直接添加到编程语言中。问题在于这种方式添加了非标准的语法和关键字。为了使用范围类型，这将需要新的编译器或新的反编译器。同样，如上所述，这种方法是非标准的，因此随着Java的不断发展和发展，新的范围类型可能变得不兼容或过时。

这种方法虽然可行，但不是添加范围类型的有效方法。基本上，它是“拥抱并扩展”，但是扩展可能会变得不兼容，并且需要专有的编译器。

2.2使用Java语言

一种更有效且私有程度更低的方法是使用Java编程语言向Java语言添加功能。这增加了范围类型，但也不需要使用新的编译器，并且冒着将来语法和关键字不兼容的风险。

使用Java编程语言，在语法方面有两种方法：

使用通过类访问的静态方法。
将静态方法与Java的静态导入功能一起使用。

静态导入功能是在2004年[Orac 2004]中添加到Java 5的，因此使用该功能需要Java版本5或更高版本。

2.2.1实施方法

对于此功能，Java的Iterator接口可用于创建虚拟数据结构-Range类型。但是，此Range类型不是具有整数列表的实际数据结构，而是虚拟数据结构。与Python和Ada示例相似的for-each循环使用的语法示例为：

for(Integer n : Range.of(0,10)){ 
  System.out.print(n); 
  System.out.println();
}//end for

如语法所示，具有“ of()”的Range类的作用类似于Java中的迭代器，并实现了Java迭代器。

2.2.2使用迭代器

迭代器是“四人帮” [Gamm 1994]设计模式书中的经典设计模式。 Java [ZetC 2020]于1998年12月在Java 1.2中引入了与Java集合一起使用的语言标准迭代器。从Java 5开始，可以使用Java for-each循环语法遍历实现Iterable接口(从其唯一方法返回Iterator实例)的对象。

迭代器带来了迭代器设计模式，这是一种常见的行为模式，用于按顺序访问集合对象的元素，而无需了解其基础表示。

Java迭代器是具有四个方法的接口，但是Range类型仅使用两个方法：“ hasNext()”和“ next()”。对于范围类型，方法“ iterator()”非常重要，因为它会在上下边界的值范围内创建迭代器。

3.范围的实现

Java中Range类型的实现需要两个类：

Range –用于创建范围并通过范围类型获取迭代器的类。
RangeIterator –实现Iterator接口和所需方法的类。

Range类是虚拟数据结构，而RangeIterator类将遍历Range数据结构。

3.1范围等级

Range类是从范围的开始到结束的整数列表的“虚拟”数据结构。 Range类创建一个范围并获取给定范围的迭代器。静态工厂方法创建一个迭代器，该迭代器用于遍历整数的“虚拟”数据结构列表。

Range类围绕三个区域组织：

类属性和构造函数可初始化这些属性。
类的迭代器方法和工厂方法可创建范围类型。
类访问器方法获取类属性。

3.1.1。范围类属性和构造函数

Range类的属性和构造函数为：

public final class Range implements Iterable<Integer> {

  private final int begin; 
  private final int close; 
  private final int index;

  public Range(final int begin, final int close) { 
    this(begin, close, 1);
  }//end constructor

  public Range(final int begin, final int close, final int index) { 
    this.begin = begin;
    this.close = close;
    this.index = index;
  }//end constructor

  //...

}//end class Range

3.1.2范围类迭代器方法和工厂方法

Range类的迭代器方法和factor方法是：

public final class Range implements Iterable<Integer> { 

  //...

  public static Range of(final int begin, final int close) { 
    return new Range(begin, close);
  }//end of

  public static Range of(final int begin, final int close, final int index) { 
    return new Range(begin, close, index);
  }//end of

  public static Range to(final int begin, final int close) { 
    return new Range(begin, close+1);
  }//end to

  public static Range to(final int begin, final int close, final int index) { 
     return new Range(begin, close+1, index);
  }//end to

  public boolean in(final int value) { 
    //...
  }//end of

  public Iterator<Integer> iterator() { 
    return new RangeIterator<>(this);
  }//end iterator 

}//end class Range

3.1.3范围类访问器方法

用于范围的开始和结束以及索引的Range类访问器方法是：

public final class Range implements Iterable<Integer> { 

  //...

  public int getBegin() { 
    return this.begin;
  }//end getBegin

  public int getClose() { 
    return this.close;
  }//end getClose

  public int getIndex() { 
    return this.index;
  }//end getIndex

}//end class Range

3.2范围方法

Range类中范围类型的三个核心方法是：

of –是创建从包含下限到专有上界的范围。
到–是创建从包含下限到包含上限的范围。
in –验证是否在从下限到上限的范围内(包括端点)。

3.2.1()方法的范围

Range.of()方法创建一个范围，该范围从下限开始，在上限处关闭，但是当迭代器的值小于…时，上限是互斥的。 Range类型的源代码，以及更基本的for循环等效项是：

for(Integer idx : Range.of(0,10)){ 
  //...
}//end for

for(int idx=0; idx<10; idx++){ 
  //...
}//end for

3.2.2范围to()方法

Range.to()方法创建一个范围，该范围从下限开始，在上限处关闭，但是当迭代器的值等于…时，上限是包含在内的。 Range类型的源代码，以及更基本的for循环等效项是：

for(Integer idx : Range.to(0,10)){ 
  //...
}//end for

for(int idx=0; idx <= 10; idx++){ 
  //...
}//end for

3.2.3 Range in()方法

Range“ in()”方法验证值是否在给定范围类型的范围边界内。

3.2.3.1范围“ in()”方法的实现

“ in()”方法分两个步骤实现：

检查该值是否在范围的上下限内。
如果在范围边界内，请检查指数的模数是否为零-以便该值是该范围内的倍数。

实现“ in()”方法的源代码更加明确：

public final class Range implements Iterable<Integer> { 

  //...

  public boolean in(final int val) {

    if(val < this.begin || val > this.close) return false; //val within range return (((val - this.begin) % this.index) == 0); //val reachable by index
  }//end in

  //...

}//end class Range

3.2.3.2使用范围“ in()”方法

Range类型的源代码，以及更基本的if-then等效项，用于range“ of()”方法：

if(Range.of(0,10).in(x)){ 
  //...
}//end if

if(x <=0 &amp;&amp; x < 10){ 
  //...
}//end if

Range类型的源代码，更基本的if-then等效项是范围“ to()”方法：

if(Range.to(0,10).in(x)){ 
  //...
}//end if

if(x <=0 &amp;&amp; x <= 10){ 
  //...
}//end if

3.3范围迭代器类

RangeIterator是实现迭代器并在遍历Range的“虚拟”数据结构的过程中的每一步返回整数的类。 Java中的RangeIterator类定义为：

public final class RangeIterator<T> implements Iterator<T> {

  private int idx = -1; //increment index 
  private int pos = 0;  //position in range

  private int begin = -1; //begin value of range
  private int close = -1;//close value of range

  public RangeIterator(final Range range){
    this.begin = range.getBegin();
    this.close = range.getClose();
    this.idx.  = range.getIndex();
  }//end constructor

  public boolean hasNext(){
    return (this.begin + this.pos) < this.close;
  }//end hasNext

  public T next(){ 
    if(!this.hasNext()) {
      throw new NoSuchElementException("No further values in range."); 
    }//end if

    @SuppressWarnings("unchecked")
    T val = (T) Integer.valueOf(this.begin + this.pos); 
    this.pos = this.pos + this.idx;
    return val;
  }//end next

  public void remove(){
    throw new UnsupportedOperationException("Remove is not supported.");
  }//end remove

}//end class RangeIterator

RangeIterator很简单，实现了必要的功能以遍历整个范围。未实现函数“ remove()”，因为没有要删除的实际数据。

3.4使用静态导入的范围

在Java中，静态导入概念在1.5版本中引入。使用静态导入，我们可以直接访问类的静态成员，而无需类名或任何对象。这可以使用Range的Range类的静态方法(而不是类名和静态方法)来进行更紧凑和简洁的访问。

3.4.1静态导入

静态导入允许包含和使用类的静态元素，而无需静态引用该类。这样可以更简洁地表达所使用的静态属性和方法。这种简洁可以用于使用方法名称而不是语法中的整个类和方法来包括范围类型。

3.4.2添加到范围类的方法

通过静态导入，可以使用静态方法“ of()”和“ to()”，但它们是非常短的方法，对于范围可能是隐秘的方法。因此，使用了更具表达性的名称，这些名称与Range类中的方法“ of()”和“ to()”等效。

3.4.2.1方法范围()

方法“ range()”等效于方法“ of()”，因为它从起始值创建一个迭代器，并从索引值迭代到结束值。但收盘价不包括在该范围内。结束值是范围的上限，但不包括在范围内。

3.4.2.2方法系列()

方法“ series()”等效于方法“ to()”，因为它从起始值创建一个迭代器，并按索引值迭代到结束值。但是收盘价包含在该范围内。结束值是范围的上限，并且包含在范围中。

3.4.2.3类源代码

“ range()”方法和“ series()”方法的源代码都只是分别包装“ of()”和“ to()”方法。

public final class Range implements Iterable<Integer> { 

  //...

  public static Range range(final int begin, final int close){ 
    return Range.of(begin, close);
  }//end range

  public static Range range(final int begin, final int close, final int index){ 
    return Range.of(begin, close, index);
  }//end range

  public static Range series(final int begin, final int close) { 
    return Range.to(begin, close+1);
  }//end series

  public static Range to(final int begin, final int close, final int index) { 
    return Range.to(begin, close+1, index);
  }//end series
  
  public boolean in(final int value) { 
    //...
  }//end in
  
  public Iterator<Integer> iterator() { 
    return new RangeIterator<>(this);
  }//end iterator 

}//end class Range

3.4.3使用“ range()”和“ series()”的示例

静态导入使用的“ range()”和“ series()”静态函数在for循环和if语句中都使用。

import static com.javacodegeeks.rangeiterator.Range.*; 

//...

int[] myArray = new int[100];

//initialize array with integer index
for(Integer i : range(0,myArray.length)){ 
  myArray[i] = i;
}//end for

int intVal = 3;

//check if even number from 0 to 100
if(series(0,100,2).in(intVal)){
  System.out.printf(“Number: %d is even from 0 to 100!%n”,intVal);
}//end if

两个示例都说明，在Java源代码中使用范围类型可以简化功能并使之更加明确。使用“ series()”函数对if语句的传统实现更加晦涩难懂。

//check if even number from 0 to 100 using series function
if(series(0,100,2).in(intVal)){
  System.out.printf(“Number: %d is even from 0 to 100!%n”,intVal);
}//end if

//check if even number in traditional if statement syntax 
if(intVal >= 0 &amp;&amp; intVal <= 100 &amp;&amp; ((intVal %2 ) == 0)){
  System.out.printf(“Number: %d is even from 0 to 100!%n”,intVal); }//end if

软件开发人员必须首先确定关系子表达式所表示的含义，然后将其除以二，得到零。使用范围类型的“ series()”函数，意图更加明确。

4.申请

通过类和迭代器添加到Java的范围类型最好用示例来说明-一个简单的应用程序，通常以Java的一种方式实现，现在使用新的范围类型来实现。通过比较，可以客观地在源代码前后进行对比。

4.1原始性检查

这个简单的应用程序是Java中的布尔函数，用于测试素数。这是通常由学生实施并在计算机科学教科书中提供的常用功能[Wiki 2020]，并且源代码在Java相关的网页和网站上在线提供。

函数“ isPrime”确定整数是否为质数，并返回布尔值true或false。该函数检查该数字是否可被二整除并且小于二(如果是)，则该数字不是素数。如果数字为2，则为质数。然后，除以3到整数平方根的所有奇数，以检查余数是否为零。如果是这样，则该数字不是素数。否则，该数字为质数。

第一个功能是使用传统的for循环实现的，然后使用同时使用Range类型(带静态导入和不带静态导入)的for-each循环来实现。

4.1.1使用For循环的函数“ isPrime()”

函数“ isPrime()”使用带有三个子表达式的传统C样式for循环。

public static boolean isPrime(final int number){ 

  if (num <= 3) {
    return (num > 1);
  } else if ((num % 2) == 0 || (num % 3) == 0) {
    return false;
  }//end if

  final int SQRT = (int) Math.sqrt(number) + 1;

  for(int i=3 ; i < SQRT ; i++){ 
    if(number % i == 0){
      return false; 
    }//end if
  }//end for

  return true; 

}//end isPrime

4.1.2使用范围类型的函数“ isPrime()”

函数“ isPrime()”在for循环的范围内使用范围类中的显式静态方法“ of()”。

public static boolean isPrime(final int number){ 

  if (num <= 3) {
    return (num > 1);
  } else if ((num % 2) == 0 || (num % 3) == 0) {
    return false;
  }//end if

  final int SQRT = (int) Math.sqrt(number) + 1;

  for(Integer i : Range.of(3, SQRT, 2)) { 
    if(number % i == 0) {
      return false; 
    }//end if
  }//end for

  return true; 

}//end isPrime

4.1.3使用静态导入的函数“ isPrime()”

函数“ isPrime()”使用静态导入对for循环的范围使用“ range()”方法。

public static boolean isPrime(final int number){ 

  if (num <= 3) {
    return (num > 1);
  } else if ((num % 2) == 0 || (num % 3) == 0) {
    return false;
  }//end if

  final int SQRT = (int) Math.sqrt(number) + 1;

  for(Integer i : range(3, SQRT, 2)) { 
    if(number % i == 0) {
      return false; 
    }//end if
  }//end for

  return true; 

}//end isPrime

4.2功能实现比较

相同“ isPrime()”函数的所有三个版本实质上具有相同数量的代码行和代码结构。因此，范围类型不会更改长度或结构。

主要区别在于范围类型在功能上更加明确和富有表现力。乍看之下，软件开发工程师可以看到正在使用“ Range.of”或“ range”来确定数字是否为质数。

考虑各种语法彼此接近的for语句：

for(int i=3 ; i < SQRT ; i++){ //traditional for loop

for(Integer i : Range.of(3, SQRT, 2)) { //Range “of()” for-each loop 

for(Integer i : range(3, SQRT, 2)) { //static import range for-each loop

使用范围类型的for-each循环的语法大小并不小，但是在for-each循环的具体参数方面更明确。

另一个区别是语法简洁，简洁。传统的for循环具有三个子表达式，并且可能存在错误，例如臭名昭著的“ off by one”错误。在范围内，边界是明确的，没有子表达式必须一起使用才能确定for循环函数。

使用范围类型可简化所使用的for循环，使其更加简洁和简单。这使得使用范围时间的“ isPrime()”函数与for循环的参数一起更具表现力，更简单并且更不易出错。

5.结论

范围类型为Java语言增加了功能和表达能力，可在其他编程语言(例如Python，Ada和Rust)中使用。如图所示，Java中的范围类型添加了更紧凑，更具表现力的源代码。范围类型的功能还允许Java具有语言评论家可以认为缺少的功能。

范围类型是在其他非Java语言(例如Rust，Ada和Python)中发现的功能。范围类型提供的功能可用于在源代码中创建显式但定义明确的功能。 Java编程语言缺乏范围类型的功能，这是一个功能上的差距。

Java是一种流行的编程语言，但它也具有现有功能，并且可以通过扩展语言来添加新功能。通过向语言添加范围类型而无需非规范扩展名或专用预处理器或反编译器，即可证明此功能。增加的功能是Java编程语言的其他功能的总和。

范围类型为Java编程语言增加了功能和表示能力，允许在范围内进行迭代，还可以测试范围的包含或排除。因此，Java作为一种编程语言在总体上得到了丰富。

将来，Java编程语言可能会在规范中的Java语言中添加范围类型，但目前该功能可通过使用Java功能的实现来使用。

6.参考

[Gamm 1994] Gamma，Erich，Helm，Richard，Johnson，Ralph和Vlissides，John。

“ 设计模式：可重用的面向对象软件的元素”，Addison Wesley，马萨诸塞州雷丁，1994年，第257页。[Mozi 2019] Mozilla Corporation。

Klabnik，Steve和Nichols，Carol，作者。

Rust编程语言，No Starch出版社，加利福尼亚州旧金山，2019年，第1页。

57. [Orac 2004] Oracle Corporation。

“新功能和增强J2SE 5.0”，2004年。https ://docs.oracle.com/javase/1.5.0/docs/relnotes/features.html，于2020年7月14日访问。[Pras 2012] Prasanna，DhanjiR。 “语言，Verbosity和Java”，informIT，2012年1月5日。http://www.informit.com/articles/article.aspx? p=1824790，于2020年2月6日访问。[PYna 2020] PYnative，“ Python range()函数用示例解释，” 2020年1月1日， https ：//pynative.com/python-range-function/，于2020年2月2日访问。[Ruby 2020] Ruby Documentation Project，“ Range”， https：/ /ruby-doc.org/core-2.5.1/Range.html于2020年2月23日访问。[Wiki 2017] Wikibooks，“ Ada编程”，2017年7月31日， https： //en.wikibooks.org/wiki/ Ada_Programming / Types / range ，于2020年2月2日访问。[Wiki 2020] Wikipedia，“ Primality Test”，2020年6月20日， https： //en.wikipedia.org/wiki/Primality_test，于2020年7月13日访问。[ZetC 2020年] ZetCode，“ Java元素迭代的历史”，2020年7月13日。http: //zetcode.com/articles/javaiterationhistory/ Acces

sed 2020年7月13日。

7.致谢

作者非常感谢他的同事，朋友Andrew Gauger的建议，帮助，评论和建议，并提供了本文中的Ruby和Rust示例。

8.下载源代码

下载您可以在此处下载本文的完整源代码： 在Java中添加范围类型

翻译自: https://www.javacodegeeks.com/adding-range-type-in-java.html

java安装

cunfen6312

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java安装_在Java中添加范围类型

java安装1.简介现代和最近的编程语言都具有范围类型的概念。诸如Python，Ada，Ruby和Rust之类的编程语言都具有范围的概念-范围是数字序列或整数序列的有界起点和终点。 Java编程语言因其本身就是冗长，冗长的编程语言而享誉盛名[Pras 2012]。但是，Java语言中没有范围类型。这是Java语言的缺陷，但是使用现有的Java语言功能，范围类型很容易添加到编程语言中。...
复制链接

扫一扫