blocks|key|1718445|text|你有两个选择：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1718446|数组上的java.util.Arrays.binarySearch+|unordered-list-item|offset|length|style|CODE|1718447|(对于不同的数组类型具有不同的重载)|1718448|1718449|​|1718450|java.util.Collections.binarySearch+on+List+|1718451|(使用Comparable和Comparator重载)。|1718452|结合List.subList(int+fromIndex,+int+toIndex)搜索列表的部分|1718453|1718454|1718455|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/javase/6/docs/api/java/util/Arrays.html#binarySearch%2528int%255B%255D,%2520int%2529|1|http://java.sun.com/javase/6/docs/api/java/util/Collections.html#binarySearch%2528java.util.List,%2520T%2529|2|http://java.sun.com/javase/6/docs/api/java/util/List.html|3|http://java.sun.com/javase/6/docs/api/java/lang/Comparable.html|4|http://java.sun.com/javase/6/docs/api/java/util/Comparator.html|5|http://java.sun.com/javase/6/docs/api/java/util/List.html#subList%2528int,%2520int%2529^0|0|4|T|4|T|0|1|1|0|0|0|Y|12|4|0|Y|1|12|4|2|1|3|A|E|A|3|A|3|E|A|4|1|2|14|2|14|5|1|0|0^^$0|@$1|2|3|4|5|6|7|1D|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1E|8|@$E|1F|F|1G|G|H]]|9|@$E|1H|F|1I|1|1J]]|A|$]]|$1|I|3|J|5|D|7|1K|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|1M|8|@]|9|@]|A|$]]|$1|N|3|O|5|D|7|1N|8|@$E|1O|F|1P|G|H]|$E|1Q|F|1R|G|H]]|9|@$E|1S|F|1T|1|1U]|$E|1V|F|1W|1|1X]]|A|$]]|$1|P|3|Q|5|D|7|1Y|8|@$E|1Z|F|20|G|H]|$E|21|F|22|G|H]]|9|@$E|23|F|24|1|25]|$E|26|F|27|1|28]]|A|$]]|$1|R|3|S|5|D|7|29|8|@$E|2A|F|2B|G|H]]|9|@$E|2C|F|2D|1|2E]]|A|$]]|$1|T|3|-4|5|6|7|2F|8|@]|9|@]|A|$]]|$1|U|3|M|5|6|7|2G|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|2H|8|@]|9|@]|A|$]]]|W|$X|$5|Y|Z|10|A|$11|12]]|13|$5|Y|Z|10|A|$11|14]]|15|$5|Y|Z|10|A|$11|16]]|17|$5|Y|Z|10|A|$11|18]]|19|$5|Y|Z|10|A|$11|1A]]|1B|$5|Y|Z|10|A|$11|1C]]]]

You have two options:

<ul>
<li><a href="http://java.sun.com/javase/6/docs/api/java/util/Arrays.html#binarySearch%28int%5B%5D,%20int%29" rel="noreferrer"><code>java.util.Arrays.binarySearch</code></a> on arrays

<ul>
<li>(with various overloads for different array types)</li>
</ul></li>
<li><a href="http://java.sun.com/javase/6/docs/api/java/util/Collections.html#binarySearch%28java.util.List,%20T%29" rel="noreferrer"><code>java.util.Collections.binarySearch</code></a> on <a href="http://java.sun.com/javase/6/docs/api/java/util/List.html" rel="noreferrer"><code>List</code></a>

<ul>
<li>(with <a href="http://java.sun.com/javase/6/docs/api/java/lang/Comparable.html" rel="noreferrer"><code>Comparable</code></a> and <a href="http://java.sun.com/javase/6/docs/api/java/util/Comparator.html" rel="noreferrer"><code>Comparator</code></a> overloads).</li>
<li>Combine with <a href="http://java.sun.com/javase/6/docs/api/java/util/List.html#subList%28int,%20int%29" rel="noreferrer"><code>List.subList(int fromIndex, int toIndex)</code></a> to search portion of a list</li>
</ul></li>
</ul>

blocks|key|168572|text|为了完整起见，这里有一个小小的java函数，它将来自Arrays.binarySearch的输出转换为接近bisect_left输出的东西。很明显，我错过了一些东西，但这对这个简单的案子来说是可行的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|168573|public+static+int+bisectLeft(double[]+a,+double+key)+{
++++int+idx+=+Math.min(a.length,+Math.abs(Arrays.binarySearch(a,+key)));
++++while+(idx+>+0+&&+a[idx+-+1]+>=+key)+idx--;
++++return+idx;
}|code-block|syntax|javascript|168574|entityMap^0|Q|J|1H|B|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

Just for completeness, here's a little java function that turns the output from <code>Arrays.binarySearch</code> into something close to the output from <code>bisect_left</code>. I'm obviously missing things, but this does the job for the simple case.

<pre><code>public static int bisectLeft(double[] a, double key) {
 int idx = Math.min(a.length, Math.abs(Arrays.binarySearch(a, key)));
 while (idx &gt; 0 &amp;&amp; a[idx - 1] &gt;= key) idx--;
 return idx;
}
</code></pre>

blocks|key|1718473|text|到目前为止(Java+8)，这仍然是缺失的，所以您仍然必须创建自己的。这是我的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1718474|public+static+int+bisect_right(int[]+A,+int+x)+{
++++return+bisect_right(A,+x,+0,+A.length);
}

public+static+int+bisect_right(int[]+A,+int+x,+int+lo,+int+hi)+{
++++int+N+=+A.length;
++++if+(N+==+0)+{
++++++++return+0;
++++}
++++if+(x+<+A[lo])+{
++++++++return+lo;
++++}
++++if+(x+>+A[hi+-+1])+{
++++++++return+hi;
++++}
++++for+(;;)+{
++++++++if+(lo+%2B+1+==+hi)+{
++++++++++++return+lo+%2B+1;
++++++++}
++++++++int+mi+=+(hi+%2B+lo)+/+2;
++++++++if+(x+<+A[mi])+{
++++++++++++hi+=+mi;
++++++++}+else+{
++++++++++++lo+=+mi;
++++++++}
++++}
}

public+static+int+bisect_left(int[]+A,+int+x)+{
++++return+bisect_left(A,+x,+0,+A.length);
}

public+static+int+bisect_left(int[]+A,+int+x,+int+lo,+int+hi)+{
++++int+N+=+A.length;
++++if+(N+==+0)+{
++++++++return+0;
++++}
++++if+(x+<+A[lo])+{
++++++++return+lo;
++++}
++++if+(x+>+A[hi+-+1])+{
++++++++return+hi;
++++}
++++for+(;;)+{
++++++++if+(lo+%2B+1+==+hi)+{
++++++++++++return+x+==+A[lo]+?+lo+:+(lo+%2B+1);
++++++++}
++++++++int+mi+=+(hi+%2B+lo)+/+2;
++++++++if+(x+<=+A[mi])+{
++++++++++++hi+=+mi;
++++++++}+else+{
++++++++++++lo+=+mi;
++++++++}
++++}
}|code-block|syntax|javascript|1718475|测试时(X是存储我打算重用的静态方法的类)：|1718476|@Test
public+void+bisect_right()+{
++++System.out.println("bisect_rienter+code+hereght");
++++int[]+A+=+new+int[]{0,+1,+2,+2,+2,+2,+3,+3,+5,+6};
++++assertEquals(0,+X.bisect_right(A,+-1));
++++assertEquals(1,+X.bisect_right(A,+0));
++++assertEquals(6,+X.bisect_right(A,+2));
++++assertEquals(8,+X.bisect_right(A,+3));
++++assertEquals(8,+X.bisect_right(A,+4));
++++assertEquals(9,+X.bisect_right(A,+5));
++++assertEquals(10,+X.bisect_right(A,+6));
++++assertEquals(10,+X.bisect_right(A,+7));
}

@Test
public+void+bisect_left()+{
++++System.out.println("bisect_left");
++++int[]+A+=+new+int[]{0,+1,+2,+2,+2,+2,+3,+3,+5,+6};
++++assertEquals(0,+X.bisect_left(A,+-1));
++++assertEquals(0,+X.bisect_left(A,+0));
++++assertEquals(2,+X.bisect_left(A,+2));
++++assertEquals(6,+X.bisect_left(A,+3));
++++assertEquals(8,+X.bisect_left(A,+4));
++++assertEquals(8,+X.bisect_left(A,+5));
++++assertEquals(9,+X.bisect_left(A,+6));
++++assertEquals(10,+X.bisect_left(A,+7));
}|1718477|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

To this date (Java 8), this is still missing, so you must still make your own. Here's mine:

<pre><code>public static int bisect_right(int[] A, int x) {
 return bisect_right(A, x, 0, A.length);
}

public static int bisect_right(int[] A, int x, int lo, int hi) {
 int N = A.length;
 if (N == 0) {
 return 0;
 }
 if (x &lt; A[lo]) {
 return lo;
 }
 if (x &gt; A[hi - 1]) {
 return hi;
 }
 for (;;) {
 if (lo + 1 == hi) {
 return lo + 1;
 }
 int mi = (hi + lo) / 2;
 if (x &lt; A[mi]) {
 hi = mi;
 } else {
 lo = mi;
 }
 }
}

public static int bisect_left(int[] A, int x) {
 return bisect_left(A, x, 0, A.length);
}

public static int bisect_left(int[] A, int x, int lo, int hi) {
 int N = A.length;
 if (N == 0) {
 return 0;
 }
 if (x &lt; A[lo]) {
 return lo;
 }
 if (x &gt; A[hi - 1]) {
 return hi;
 }
 for (;;) {
 if (lo + 1 == hi) {
 return x == A[lo] ? lo : (lo + 1);
 }
 int mi = (hi + lo) / 2;
 if (x &lt;= A[mi]) {
 hi = mi;
 } else {
 lo = mi;
 }
 }
}
</code></pre>

Tested with (X being the class where I store static methods that I intend to reuse):

<pre><code>@Test
public void bisect_right() {
 System.out.println("bisect_rienter code hereght");
 int[] A = new int[]{0, 1, 2, 2, 2, 2, 3, 3, 5, 6};
 assertEquals(0, X.bisect_right(A, -1));
 assertEquals(1, X.bisect_right(A, 0));
 assertEquals(6, X.bisect_right(A, 2));
 assertEquals(8, X.bisect_right(A, 3));
 assertEquals(8, X.bisect_right(A, 4));
 assertEquals(9, X.bisect_right(A, 5));
 assertEquals(10, X.bisect_right(A, 6));
 assertEquals(10, X.bisect_right(A, 7));
}

@Test
public void bisect_left() {
 System.out.println("bisect_left");
 int[] A = new int[]{0, 1, 2, 2, 2, 2, 3, 3, 5, 6};
 assertEquals(0, X.bisect_left(A, -1));
 assertEquals(0, X.bisect_left(A, 0));
 assertEquals(2, X.bisect_left(A, 2));
 assertEquals(6, X.bisect_left(A, 3));
 assertEquals(8, X.bisect_left(A, 4));
 assertEquals(8, X.bisect_left(A, 5));
 assertEquals(9, X.bisect_left(A, 6));
 assertEquals(10, X.bisect_left(A, 7));
}
</code></pre>

blocks|key|1718493|text|为什么不尝试并测试本身的快速端口+Python代码呢？例如，这里有一个用于bisect_right的Java端口：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|1718494|public+static+int+bisect_right(double[]+A,+double+x)+{
++return+bisect_right(A,+x,+0,+A.length);
}

private+static+int+bisect_right(double[]+A,+double+x,+int+lo,+int+hi)+{
++while+(lo+<+hi)+{
++++int+mid+=+(lo%2Bhi)/2;+
++++if+(x+<+A[mid])+hi+=+mid;+
++++else+lo+=+mid%2B1;
++}
++return+lo;+
}|code-block|syntax|javascript|1718495|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/python/cpython/blob/3.6/Lib/bisect.py#L24^0|9|7|11|C|H|8|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|D]]|E|@$9|Y|A|Z|1|10]]|F|$]]|$1|G|3|H|5|I|7|11|8|@]|E|@]|F|$J|K]]|$1|L|3|-4|5|6|7|12|8|@]|E|@]|F|$]]]|M|$N|$5|O|P|Q|F|$R|S]]]]

Why not do a quick port of the tried and tested <a href="https://github.com/python/cpython/blob/3.6/Lib/bisect.py#L24" rel="nofollow noreferrer">Python code</a> itself? For example, here's a Java port for <code>bisect_right</code>: 

<pre><code>public static int bisect_right(double[] A, double x) {
 return bisect_right(A, x, 0, A.length);
}

private static int bisect_right(double[] A, double x, int lo, int hi) {
 while (lo &lt; hi) {
 int mid = (lo+hi)/2; 
 if (x &lt; A[mid]) hi = mid; 
 else lo = mid+1;
 }
 return lo; 
}
</code></pre>

blocks|key|168683|text|基于java.util.Arrays.binarySearch+文档的|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|168684|这里我使用了long[]数组的示例，但是可以对代码进行调整，以利用任何受支持的类型。|168685|int+bisectRight(long[]+arr,+long+key)+{
++++int+index+=+Arrays.binarySearch(arr,+key);
++++return+Math.abs(index+%2B+1);
}|code-block|syntax|javascript|168686|注释:javadoc的限制，来自javadoc的以下句子：|BOLD|168687|If+the+array+contains+multiple+elements+with+the+specified+value,
there+is+no+guarantee+which+one+will+be+found|168688|实际上，我已经用排序好的不同元素数组测试了这一点。我的用例是用于范围分组，其中arr是一组不同的时间戳，指示间隔的开始时间。|168689|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Arrays.html#binarySearch(long[],long)^0|2|T|W|2|0|0|6|6|0|0|0|T|0|0|13|3|0^^$0|@$1|2|3|4|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@$9|14|A|15|1|16]]|E|$]]|$1|F|3|G|5|6|7|17|8|@$9|18|A|19|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|1A|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1B|8|@$9|1C|A|1D|B|O]]|D|@]|E|$]]|$1|P|3|Q|5|J|7|1E|8|@]|D|@]|E|$K|L]]|$1|R|3|S|5|6|7|1F|8|@$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|T|3|-4|5|6|7|1I|8|@]|D|@]|E|$]]]|U|$V|$5|W|X|Y|E|$Z|10]]]]

Based on the <code>java.util.Arrays.binarySearch</code> <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Arrays.html#binarySearch(long%5B%5D,long)" rel="nofollow noreferrer">documentation</a>
Here I use the example for a <code>long[]</code> array,
but one can adapt the code to utilize any of the supported types.
<pre class="lang-java prettyprint-override"><code>int bisectRight(long[] arr, long key) {
 int index = Arrays.binarySearch(arr, key);
 return Math.abs(index + 1);
}
</code></pre>
Note: Limitation on the java API, by the following sentence from javadoc:
<pre><code>If the array contains multiple elements with the specified value,
there is no guarantee which one will be found
</code></pre>
Indeed, I've tested that with sorted array of distinct elements.
My use-case was for range grouping, where <code>arr</code> an array of distinct timestamps that indicate the start time of an interval.

blocks|key|1388388|text|你需要自己来定义，这是我的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1388389|bisect.bisect_left|offset|length|style|BOLD|1388390|public+static+int+bisectLeft(int[]+nums,+int+target)+{
++++int+i+=+0;
++++int+j+=+nums.length+-+1;
++++while+(i+<=+j)+{
++++++++int+m+=+i+%2B+(j-i)+/+2;
++++++++if+(nums[m]+>=+target)+{
++++++++++++j+=+m+-+1;
++++++++}+else+{
++++++++++++i+=+m+%2B+1;
++++++++}
++++}
++++return+i;
}|code-block|syntax|javascript|1388391|bisect.bisect_right|1388392|public+static+int+bisectRight(int[]+nums,+int+target)+{
++++int+i+=+0;
++++int+j+=+nums.length+-+1;
++++while+(i+<=+j)+{
++++++++int+m+=+i+%2B+(j-i)+/+2;
++++++++if+(nums[m]+<=+target)+{
++++++++++++i+=+m+%2B+1;
++++++++}+else+{
++++++++++++j+=+m+-+1;
++++++++}
++++}
++++return+j%2B1;
}|1388393|entityMap^0|0|0|I|0|0|0|J|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@$D|U|E|V|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|W|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|X|8|@$D|Y|E|Z|F|G]]|9|@]|A|$]]|$1|O|3|P|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

You need to define on your own, here's mine:
bisect.bisect_left
<pre class="lang-java prettyprint-override"><code>public static int bisectLeft(int[] nums, int target) {
 int i = 0;
 int j = nums.length - 1;
 while (i &lt;= j) {
 int m = i + (j-i) / 2;
 if (nums[m] &gt;= target) {
 j = m - 1;
 } else {
 i = m + 1;
 }
 }
 return i;
}
</code></pre>
bisect.bisect_right
<pre class="lang-java prettyprint-override"><code>public static int bisectRight(int[] nums, int target) {
 int i = 0;
 int j = nums.length - 1;
 while (i &lt;= j) {
 int m = i + (j-i) / 2;
 if (nums[m] &lt;= target) {
 i = m + 1;
 } else {
 j = m - 1;
 }
 }
 return j+1;
}
</code></pre>

blocks|key|1718638|text|这里是一个通用的变量，它使用int->布尔函数而不是数组。它找到谓词变化的第一个索引。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1718639|public+class+Bisect+{

++++/**
+++++*+Look+for+the+last+index+i+in+[min,+max]+such+that+f(i)+is+false.
+++++*
+++++*+@param+function+monotonous+function+going+from+false+to+true+in+the+[min,+max]+interval
+++++*/
++++public+static+int+bisectLeft(Function<Integer,+Boolean>+function,+int+min,+int+max)+{
++++++++if+(max+==+min)+{
++++++++++++return+max;
++++++++}
++++++++if+(function.apply(min))+{
++++++++++++return+min;
++++++++}
++++++++if+(!function.apply(max))+{
++++++++++++return+max;
++++++++}
++++++++while+(true)+{
++++++++++++if+(min+%2B+1+==+max)+{
++++++++++++++++return+min;
++++++++++++}
++++++++++++int+middle+=+(max+%2B+min)+/+2;
++++++++++++if+(function.apply(middle))+{
++++++++++++++++max+=+middle;
++++++++++++}+else+{
++++++++++++++++min+=+middle;
++++++++++++}
++++++++}
++++}

++++/**
+++++*+Look+for+the+first+index+i+in+[min,+max]+such+that+f(i)+is+true.
+++++*
+++++*+@param+function+monotonous+function+going+from+false+to+true+in+the+[min,+max]+interval
+++++*/
++++public+static+int+bisectRight(Function<Integer,+Boolean>+function,+int+min,+int+max)+{
++++++++if+(max+==+min)+{
++++++++++++return+max;
++++++++}
++++++++if+(function.apply(min))+{
++++++++++++return+min;
++++++++}
++++++++if+(!function.apply(max))+{
++++++++++++return+max;
++++++++}
++++++++while+(true)+{
++++++++++++if+(min+%2B+1+==+max)+{
++++++++++++++++return+max;
++++++++++++}
++++++++++++int+middle+=+(max+%2B+min)+/+2;
++++++++++++if+(function.apply(middle))+{
++++++++++++++++max+=+middle;
++++++++++++}+else+{
++++++++++++++++min+=+middle;
++++++++++++}
++++++++}
++++}
}|code-block|syntax|javascript|1718640|例如，要在数组中找到插入点，函数将插入的值与数组的值进行比较：|1718641|@Test
public+void+bisect_right()+{
++++int[]+A+=+new+int[]{0,+1,+2,+2,+2,+2,+3,+3,+5,+6};
++++assertEquals(0,+bisectRight(f(A,+-1),+0,+A.length));
++++assertEquals(1,+bisectRight(f(A,+0),+0,+A.length));
++++assertEquals(6,+bisectRight(f(A,+2),+0,+A.length));
++++assertEquals(8,+bisectRight(f(A,+3),+0,+A.length));
++++assertEquals(8,+bisectRight(f(A,+4),+0,+A.length));
++++assertEquals(9,+bisectRight(f(A,+5),+0,+A.length));
++++assertEquals(10,+bisectRight(f(A,+6),+0,+A.length));
++++assertEquals(10,+bisectRight(f(A,+7),+0,+A.length));
}

public+Function<Integer,+Boolean>+f(int[]+A,+int+x)+{
++++return+n+->+(n+>=+A.length+%7C%7C+A[n]+>+x);
}|1718642|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Derived from @Profiterole's answer, here is a generalized variant that works with an int-&gt;boolean function instead of an array. It finds the first index where the predicate changes.
<pre><code>public class Bisect {

 /**
 * Look for the last index i in [min, max] such that f(i) is false.
 *
 * @param function monotonous function going from false to true in the [min, max] interval
 */
 public static int bisectLeft(Function&lt;Integer, Boolean&gt; function, int min, int max) {
 if (max == min) {
 return max;
 }
 if (function.apply(min)) {
 return min;
 }
 if (!function.apply(max)) {
 return max;
 }
 while (true) {
 if (min + 1 == max) {
 return min;
 }
 int middle = (max + min) / 2;
 if (function.apply(middle)) {
 max = middle;
 } else {
 min = middle;
 }
 }
 }

 /**
 * Look for the first index i in [min, max] such that f(i) is true.
 *
 * @param function monotonous function going from false to true in the [min, max] interval
 */
 public static int bisectRight(Function&lt;Integer, Boolean&gt; function, int min, int max) {
 if (max == min) {
 return max;
 }
 if (function.apply(min)) {
 return min;
 }
 if (!function.apply(max)) {
 return max;
 }
 while (true) {
 if (min + 1 == max) {
 return max;
 }
 int middle = (max + min) / 2;
 if (function.apply(middle)) {
 max = middle;
 } else {
 min = middle;
 }
 }
 }
}
</code></pre>
For example, to find the insertion point in an array, the function compares the value inserted with the values of the array:
<pre><code>@Test
public void bisect_right() {
 int[] A = new int[]{0, 1, 2, 2, 2, 2, 3, 3, 5, 6};
 assertEquals(0, bisectRight(f(A, -1), 0, A.length));
 assertEquals(1, bisectRight(f(A, 0), 0, A.length));
 assertEquals(6, bisectRight(f(A, 2), 0, A.length));
 assertEquals(8, bisectRight(f(A, 3), 0, A.length));
 assertEquals(8, bisectRight(f(A, 4), 0, A.length));
 assertEquals(9, bisectRight(f(A, 5), 0, A.length));
 assertEquals(10, bisectRight(f(A, 6), 0, A.length));
 assertEquals(10, bisectRight(f(A, 7), 0, A.length));
}

public Function&lt;Integer, Boolean&gt; f(int[] A, int x) {
 return n -&gt; (n &gt;= A.length || A[n] &gt; x);
}
</code></pre>

Is there an equivalent in Java for Python's <a href="http://docs.python.org/library/bisect.html" rel="noreferrer">bisect module</a>? With Python's bisect you can do array bisection with directions. For instance <code>bisect.bisect_left</code> does:

<blockquote>
 Locate the proper insertion point for item in list to maintain sorted order. The parameters lo and hi may be used to specify a subset of the list which should be considered; by default the entire list is used.
</blockquote>

I know I can do this manually with a binary search too, but I was wondering if there is already a library or collection doing this.

Java's equivalent to bisect in python

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

的中有类似的吗？使用Python的二分法，您可以用方向进行数组二分法。例如，bisect.bisect_left确实：找到列表中项的适当插入点，以保持排序顺序。参数lo和hi可用于指定应该考虑的列表的子集；默认情况下使用整个列表。我知道我也可以通过二进制搜索手动完成这个任务，但我想知道是否已经有一个库或集合来完成此操作...

问Java等价于python中的二分
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java等价于python中的二分EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java等价于python中的二分
EN