<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>Util (Apache Calcite API)</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="description" content="declaration: package: org.apache.calcite.util, class: Util">
<meta name="generator" content="javadoc/ClassWriterImpl">
<link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../script-dir/jquery-ui.min.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../jquery-ui.overrides.css" title="Style">
<script type="text/javascript" src="../../../../script.js"></script>
<script type="text/javascript" src="../../../../script-dir/jquery-3.5.1.min.js"></script>
<script type="text/javascript" src="../../../../script-dir/jquery-ui.min.js"></script>
</head>
<body class="class-declaration-page">
<script type="text/javascript">var evenRowColor = "even-row-color";
var oddRowColor = "odd-row-color";
var tableTab = "table-tab";
var activeTableTab = "active-table-tab";
var pathtoroot = "../../../../";
loadScripts(document, 'script');</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="flex-box">
<header role="banner" class="flex-header">
<nav role="navigation">
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="top-nav" id="navbar-top">
<div class="skip-nav"><a href="#skip-navbar-top" title="Skip navigation links">Skip navigation links</a></div>
<div class="about-language"><b>Apache Calcite</b></div>
<ul id="navbar-top-firstrow" class="nav-list" title="Navigation">
<li><a href="../../../../index.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="nav-bar-cell1-rev">Class</li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../index-all.html">Index</a></li>
<li><a href="../../../../help-doc.html#class">Help</a></li>
</ul>
</div>
<div class="sub-nav">
<div>
<ul class="sub-nav-list">
<li>Summary:&nbsp;</li>
<li><a href="#nested-class-summary">Nested</a>&nbsp;|&nbsp;</li>
<li><a href="#field-summary">Field</a>&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method-summary">Method</a></li>
</ul>
<ul class="sub-nav-list">
<li>Detail:&nbsp;</li>
<li><a href="#field-detail">Field</a>&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method-detail">Method</a></li>
</ul>
</div>
<div class="nav-list-search"><label for="search-input">SEARCH:</label>
<input type="text" id="search-input" value="search" disabled="disabled">
<input type="reset" id="reset-button" value="reset" disabled="disabled">
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip-navbar-top"></span></nav>
</header>
<div class="flex-content">
<main role="main">
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="sub-title"><span class="package-label-in-type">Package</span>&nbsp;<a href="package-summary.html">org.apache.calcite.util</a></div>
<h1 title="Class Util" class="title">Class Util</h1>
</div>
<div class="inheritance" title="Inheritance Tree"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">java.lang.Object</a>
<div class="inheritance">org.apache.calcite.util.Util</div>
</div>
<section class="class-description" id="class-description">
<hr>
<div class="type-signature"><span class="modifiers">public class </span><span class="element-name type-name-label">Util</span>
<span class="extends-implements">extends <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></span></div>
<div class="block">Miscellaneous utility functions.</div>
</section>
<section class="summary">
<ul class="summary-list">
<!-- ======== NESTED CLASS SUMMARY ======== -->
<li>
<section class="nested-class-summary" id="nested-class-summary">
<h2>Nested Class Summary</h2>
<div class="caption"><span>Nested Classes</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Class</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>static class&nbsp;</code></div>
<div class="col-second even-row-color"><code><a href="Util.FoundOne.html" class="type-name-link" title="class in org.apache.calcite.util">Util.FoundOne</a></code></div>
<div class="col-last even-row-color">
<div class="block">Exception used to interrupt a tree walk of any kind.</div>
</div>
<div class="col-first odd-row-color"><code>static class&nbsp;</code></div>
<div class="col-second odd-row-color"><code><a href="Util.OverFinder.html" class="type-name-link" title="class in org.apache.calcite.util">Util.OverFinder</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Visitor which looks for an OVER clause inside a tree of
 <a href="../sql/SqlNode.html" title="class in org.apache.calcite.sql"><code>SqlNode</code></a> objects.</div>
</div>
</div>
</section>
</li>
<!-- =========== FIELD SUMMARY =========== -->
<li>
<section class="field-summary" id="field-summary">
<h2>Field Summary</h2>
<div class="caption"><span>Fields</span></div>
<div class="summary-table three-column-summary">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Field</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#FILE_SEPARATOR" class="member-name-link">FILE_SEPARATOR</a></code></div>
<div class="col-last even-row-color">
<div class="block">System-dependent file separator, for example, "/" or "\."</div>
</div>
<div class="col-first odd-row-color"><code>static final <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color"><code><a href="#FILE_TIMESTAMP_FORMAT" class="member-name-link">FILE_TIMESTAMP_FORMAT</a></code></div>
<div class="col-last odd-row-color">
<div class="block">Datetime format string for generating a timestamp string to be used as
 part of a filename.</div>
</div>
<div class="col-first even-row-color"><code>static final <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color"><code><a href="#LINE_SEPARATOR" class="member-name-link">LINE_SEPARATOR</a></code></div>
<div class="col-last even-row-color">
<div class="block">System-dependent newline character.</div>
</div>
</div>
</section>
</li>
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method-summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab1" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab1', 3)" class="table-tab">Static Methods</button><button id="method-summary-table-tab2" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab2', 3)" class="table-tab">Instance Methods</button><button id="method-summary-table-tab4" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab4', 3)" class="table-tab">Concrete Methods</button><button id="method-summary-table-tab6" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab6', 3)" class="table-tab">Deprecated Methods</button></div>
<div id="method-summary-table.tabpanel" role="tabpanel">
<div class="summary-table three-column-summary" aria-labelledby="method-summary-table-tab0">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;X&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/UnaryOperator.html" title="class or interface in java.util.function" class="external-link">UnaryOperator</a>&lt;X&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#andThen(java.util.function.UnaryOperator,java.util.function.UnaryOperator)" class="member-name-link">andThen</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/UnaryOperator.html" title="class or interface in java.util.function" class="external-link">UnaryOperator</a>&lt;X&gt;&nbsp;op1,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/UnaryOperator.html" title="class or interface in java.util.function" class="external-link">UnaryOperator</a>&lt;X&gt;&nbsp;op2)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns an operator that applies <code>op1</code> and then <code>op2</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static &lt;K,<wbr>
V&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;K,<wbr>V&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#asIndexMap(java.util.Collection,com.google.common.base.Function)" class="member-name-link">asIndexMap</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;V&gt;&nbsp;values,
 com.google.common.base.Function&lt;V,<wbr>K&gt;&nbsp;function)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;K,<wbr>
V&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;K,<wbr>V&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#asIndexMapJ(java.util.Collection,java.util.function.Function)" class="member-name-link">asIndexMapJ</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;V&gt;&nbsp;values,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/Function.html" title="class or interface in java.util.function" class="external-link">Function</a>&lt;V,<wbr>K&gt;&nbsp;function)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a map that is a view onto a collection of values, using the
 provided function to convert a value to a key.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#asStringBuilder(java.lang.Appendable,java.util.function.Consumer)" class="member-name-link">asStringBuilder</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Appendable.html" title="class or interface in java.lang" class="external-link">Appendable</a>&nbsp;appendable,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/Consumer.html" title="class or interface in java.util.function" class="external-link">Consumer</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/StringBuilder.html" title="class or interface in java.lang" class="external-link">StringBuilder</a>&gt;&nbsp;consumer)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Given an <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Appendable.html" title="class or interface in java.lang" class="external-link"><code>Appendable</code></a>, performs an action that requires a
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/StringBuilder.html" title="class or interface in java.lang" class="external-link"><code>StringBuilder</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;K,<wbr>
V&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;K,<wbr>V&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#blackholeMap()" class="member-name-link">blackholeMap</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a map which ignores any write operation.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Calendar.html" title="class or interface in java.util" class="external-link">Calendar</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#calendar()" class="member-name-link">calendar</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Calendar.html" title="class or interface in java.util" class="external-link"><code>Calendar</code></a> in the UTC time zone and root locale.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Calendar.html" title="class or interface in java.util" class="external-link">Calendar</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#calendar(long)" class="member-name-link">calendar</a><wbr>(long&nbsp;millis)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Calendar.html" title="class or interface in java.util" class="external-link"><code>Calendar</code></a> in the UTC time zone and root locale
 with a given time.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;E&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#cast(java.lang.Iterable,java.lang.Class)" class="member-name-link">cast</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;? super E&gt;&nbsp;iterable,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;E&gt;&nbsp;clazz)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts an <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link"><code>Iterable</code></a> whose members are automatically down-cast to
 a given type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E extends @PolyNull <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;<br><a href="https://docs.oracle.com/javase/9/docs/api/java/util/Iterator.html" title="class or interface in java.util" class="external-link">Iterator</a>&lt;E&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#cast(java.util.Iterator,java.lang.Class)" class="member-name-link">cast</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/Iterator.html" title="class or interface in java.util" class="external-link">Iterator</a>&lt;? extends @PolyNull <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;iter,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;E&gt;&nbsp;clazz)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a iterator whose members are automatically down-cast to a given
 type.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#cast(java.util.List,java.lang.Class)" class="member-name-link">cast</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? super E&gt;&nbsp;list,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;E&gt;&nbsp;clazz)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a list whose members are automatically down-cast to a given
 type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Throwable.html" title="class or interface in java.lang" class="external-link">Throwable</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#causeOrSelf(java.lang.Throwable)" class="member-name-link">causeOrSelf</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Throwable.html" title="class or interface in java.lang" class="external-link">Throwable</a>&nbsp;throwable)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns cause of the given throwable if it is non-null or the throwable itself.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;com.google.common.collect.ImmutableList.Builder&lt;E&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#combine(com.google.common.collect.ImmutableList.Builder,com.google.common.collect.ImmutableList.Builder)" class="member-name-link">combine</a><wbr>(com.google.common.collect.ImmutableList.Builder&lt;E&gt;&nbsp;b0,
 com.google.common.collect.ImmutableList.Builder&lt;E&gt;&nbsp;b1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Combines a second immutable list builder into a first.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/util/ArrayList.html" title="class or interface in java.util" class="external-link">ArrayList</a>&lt;E&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#combine(java.util.ArrayList,java.util.ArrayList)" class="member-name-link">combine</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/ArrayList.html" title="class or interface in java.util" class="external-link">ArrayList</a>&lt;E&gt;&nbsp;list0,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/ArrayList.html" title="class or interface in java.util" class="external-link">ArrayList</a>&lt;E&gt;&nbsp;list1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Combines a second array list into a first.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;T&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#commaList(java.util.List)" class="member-name-link">commaList</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;T&gt;&nbsp;list)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a list of a string, with commas between elements.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#contains(java.lang.String%5B%5D,int,java.lang.String)" class="member-name-link">contains</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]&nbsp;a,
 int&nbsp;length,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether an array of strings contains a given string among the
 first <code>length</code> entries.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#debugCode(java.io.PrintStream,java.lang.String)" class="member-name-link">debugCode</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/io/PrintStream.html" title="class or interface in java.io" class="external-link">PrintStream</a>&nbsp;out,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;code)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Prints the given code with line numbering.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static &lt;T&gt;&nbsp;T</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#deprecated(T,boolean)" class="member-name-link">deprecated</a><wbr>(T&nbsp;argument,
 boolean&nbsp;fail)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">If a piece of code calls this method, it indicates that the
 code needs to be cleaned up.</div>
</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#discard(boolean)" class="member-name-link">discard</a><wbr>(boolean&nbsp;b)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Does nothing with its argument.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#discard(double)" class="member-name-link">discard</a><wbr>(double&nbsp;d)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Does nothing with its argument.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#discard(int)" class="member-name-link">discard</a><wbr>(int&nbsp;i)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Does nothing with its argument.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#discard(java.lang.Object)" class="member-name-link">discard</a><wbr>(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;o)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Does nothing with its argument.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#distinctList(java.lang.Iterable)" class="member-name-link">distinctList</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;E&gt;&nbsp;keys)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts an iterable into a list with unique elements.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#distinctList(java.util.List)" class="member-name-link">distinctList</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a list into a list with unique elements.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;T extends <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Enum.html" title="class or interface in java.lang" class="external-link">Enum</a>&lt;T&gt;&gt;<br><a href="https://docs.oracle.com/javase/9/docs/api/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr>T&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#enumConstants(java.lang.Class)" class="member-name-link">enumConstants</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;T&gt;&nbsp;clazz)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a map of the values of an enumeration by name.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;T extends <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Enum.html" title="class or interface in java.lang" class="external-link">Enum</a>&lt;T&gt;&gt;<br>@Nullable T</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#enumVal(java.lang.Class,java.lang.String)" class="member-name-link">enumVal</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;T&gt;&nbsp;clazz,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the value of an enumeration with a particular name.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;T extends <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Enum.html" title="class or interface in java.lang" class="external-link">Enum</a>&lt;T&gt;&gt;<br>T</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#enumVal(T,java.lang.String)" class="member-name-link">enumVal</a><wbr>(T&nbsp;default_,
 @Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the value of an enumeration with a particular or default value if
 not found.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;T&gt;&nbsp;boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#equalShallow(java.util.List,java.util.List)" class="member-name-link">equalShallow</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends T&gt;&nbsp;list0,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends T&gt;&nbsp;list1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether two lists are equal to each other using shallow
 comparisons.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;E&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#filter(java.lang.Iterable,java.lang.Class)" class="member-name-link">filter</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;?&gt;&nbsp;iterable,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;E&gt;&nbsp;includeFilter)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Makes a collection of untyped elements appear as a list of strictly typed
 elements, by filtering out those which are not of the correct type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;E&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#filter(java.lang.Iterable,java.util.function.Predicate)" class="member-name-link">filter</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;? extends E&gt;&nbsp;iterable,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/Predicate.html" title="class or interface in java.util.function" class="external-link">Predicate</a>&lt;? super E&gt;&nbsp;predicate)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Filters an iterable.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;E&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#filter(java.util.Collection,java.lang.Class)" class="member-name-link">filter</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;collection,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;E&gt;&nbsp;includeFilter)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/util/Iterator.html" title="class or interface in java.util" class="external-link">Iterator</a>&lt;E&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#filter(java.util.Iterator,java.util.function.Predicate)" class="member-name-link">filter</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/Iterator.html" title="class or interface in java.util" class="external-link">Iterator</a>&lt;? extends E&gt;&nbsp;iterator,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/Predicate.html" title="class or interface in java.util.function" class="external-link">Predicate</a>&lt;? super E&gt;&nbsp;predicate)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Filters an iterator.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#filter(java.util.List,java.lang.Class)" class="member-name-link">filter</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;?&gt;&nbsp;list,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;E&gt;&nbsp;includeFilter)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a subset of a list containing only elements of a given type.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#findMatch(java.util.List,java.lang.String,boolean)" class="member-name-link">findMatch</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;strings,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;seek,
 boolean&nbsp;caseSensitive)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Looks for a string within a list of strings, using a given
 case-sensitivity policy, and returns the position at which the first match
 is found, or -1 if there are no matches.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#first(java.lang.Boolean,boolean)" class="member-name-link">first</a><wbr>(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&nbsp;v0,
 boolean&nbsp;v1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Unboxes a <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link"><code>Boolean</code></a> value,
 using a given default value if it is null.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static byte</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#first(java.lang.Byte,byte)" class="member-name-link">first</a><wbr>(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Byte.html" title="class or interface in java.lang" class="external-link">Byte</a>&nbsp;v0,
 byte&nbsp;v1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Unboxes a <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Byte.html" title="class or interface in java.lang" class="external-link"><code>Byte</code></a> value,
 using a given default value if it is null.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static char</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#first(java.lang.Character,char)" class="member-name-link">first</a><wbr>(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Character.html" title="class or interface in java.lang" class="external-link">Character</a>&nbsp;v0,
 char&nbsp;v1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Unboxes a <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Character.html" title="class or interface in java.lang" class="external-link"><code>Character</code></a> value,
 using a given default value if it is null.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#first(java.lang.Double,double)" class="member-name-link">first</a><wbr>(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a>&nbsp;v0,
 double&nbsp;v1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Unboxes a <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Double.html" title="class or interface in java.lang" class="external-link"><code>Double</code></a> value,
 using a given default value if it is null.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static float</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#first(java.lang.Float,float)" class="member-name-link">first</a><wbr>(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Float.html" title="class or interface in java.lang" class="external-link">Float</a>&nbsp;v0,
 float&nbsp;v1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Unboxes a <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Float.html" title="class or interface in java.lang" class="external-link"><code>Float</code></a> value,
 using a given default value if it is null.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#first(java.lang.Integer,int)" class="member-name-link">first</a><wbr>(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;v0,
 int&nbsp;v1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Unboxes a <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Integer.html" title="class or interface in java.lang" class="external-link"><code>Integer</code></a> value,
 using a given default value if it is null.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static long</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#first(java.lang.Long,long)" class="member-name-link">first</a><wbr>(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;v0,
 long&nbsp;v1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Unboxes a <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Long.html" title="class or interface in java.lang" class="external-link"><code>Long</code></a> value,
 using a given default value if it is null.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static short</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#first(java.lang.Short,short)" class="member-name-link">first</a><wbr>(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Short.html" title="class or interface in java.lang" class="external-link">Short</a>&nbsp;v0,
 short&nbsp;v1)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Unboxes a <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Short.html" title="class or interface in java.lang" class="external-link"><code>Short</code></a> value,
 using a given default value if it is null.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;T&gt;&nbsp;@PolyNull T</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#first(T,T)" class="member-name-link">first</a><wbr>(@Nullable T&nbsp;v0,
 @PolyNull T&nbsp;v1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the first value if it is not null,
 otherwise the second value.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>&lt;E&gt;&nbsp;E</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#first(java.util.List)" class="member-name-link">first</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Returns the first element of a list.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#first(java.util.List,int)" class="member-name-link">first</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list,
 int&nbsp;n)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the first <code>n</code> elements of a list.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#firstDuplicate(java.util.List)" class="member-name-link">firstDuplicate</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the ordinal of the first element in the list which is equal to a
 previous element in the list.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/nio/charset/Charset.html" title="class or interface in java.nio.charset" class="external-link">Charset</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getDefaultCharset()" class="member-name-link">getDefaultCharset</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the <a href="https://docs.oracle.com/javase/9/docs/api/java/nio/charset/Charset.html" title="class or interface in java.nio.charset" class="external-link"><code>Charset</code></a> object representing the value of
 <a href="../config/CalciteSystemProperty.html#DEFAULT_CHARSET"><code>CalciteSystemProperty.DEFAULT_CHARSET</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#getFileTimestamp()" class="member-name-link">getFileTimestamp</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#getMessages(java.lang.Throwable)" class="member-name-link">getMessages</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Throwable.html" title="class or interface in java.lang" class="external-link">Throwable</a>&nbsp;t)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#getStackTrace(java.lang.Throwable)" class="member-name-link">getStackTrace</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Throwable.html" title="class or interface in java.lang" class="external-link">Throwable</a>&nbsp;t)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use <code>Throwables.getStackTraceAsString(Throwable)</code></div>
</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#hash(int,int)" class="member-name-link">hash</a><wbr>(int&nbsp;i,
 int&nbsp;j)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Objects.html#hash(java.lang.Object...)" title="class or interface in java.util" class="external-link"><code>Objects.hash(Object...)</code></a></div>
</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#hash(int,java.lang.Object)" class="member-name-link">hash</a><wbr>(int&nbsp;h,
 @Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;o)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Objects.html#hash(java.lang.Object...)" title="class or interface in java.util" class="external-link"><code>Objects.hash(Object...)</code></a></div>
</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static int</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#hashArray(int,java.lang.Object%5B%5D)" class="member-name-link">hashArray</a><wbr>(int&nbsp;h,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>[]&nbsp;a)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Objects.html#hash(java.lang.Object...)" title="class or interface in java.util" class="external-link"><code>Objects.hash(Object...)</code></a></div>
</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static int</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#hashCode(double)" class="member-name-link">hashCode</a><wbr>(double&nbsp;v)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use <a href="../runtime/Utilities.html#hashCode(double)"><code>Utilities.hashCode(double)</code></a></div>
</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#human(double)" class="member-name-link">human</a><wbr>(double&nbsp;d)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a number into human-readable form, with 3 digits and a "K", "M"
 or "G" multiplier for thousands, millions or billions.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#immutableCopy(java.lang.Iterable)" class="member-name-link">immutableCopy</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;? extends <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;E&gt;&gt;&nbsp;lists)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a copy of a list of lists, making the component lists immutable if
 they are not already.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#intersects(java.util.Collection,java.util.Collection)" class="member-name-link">intersects</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;E&gt;&nbsp;c0,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;E&gt;&nbsp;c1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether two collections have any elements in common.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isDistinct(java.util.List)" class="member-name-link">isDistinct</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether the elements of <code>list</code> are distinct.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isNullOrEmpty(java.lang.String)" class="member-name-link">isNullOrEmpty</a><wbr>(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether s == null or if s.length() == 0.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isSingleValue(org.apache.calcite.sql.SqlCall)" class="member-name-link">isSingleValue</a><wbr>(<a href="../sql/SqlCall.html" title="class in org.apache.calcite.sql">SqlCall</a>&nbsp;call)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Does nothing with its argument.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#isValidJavaIdentifier(java.lang.String)" class="member-name-link">isValidJavaIdentifier</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns true when input string is a valid Java identifier.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;E</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#last(java.util.List)" class="member-name-link">last</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the last element of a list.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#last(java.util.List,int)" class="member-name-link">last</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list,
 int&nbsp;n)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns the last <code>n</code> elements of a list.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#lines(java.lang.Iterable)" class="member-name-link">lines</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;strings)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a list of strings to a string separated by newlines.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#listToString(java.util.List)" class="member-name-link">listToString</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;list)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts ["ab", "c"] to "ab"."c".</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;K,<wbr>
V&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;K,<wbr>V&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#mapOf(K,V,java.lang.Object...)" class="member-name-link">mapOf</a><wbr>(K&nbsp;key,
 V&nbsp;value,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>...&nbsp;keyValues)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a hashmap with given contents.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#matches(boolean,java.lang.String,java.lang.String)" class="member-name-link">matches</a><wbr>(boolean&nbsp;caseSensitive,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s0,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether a name matches another according to a given
 case-sensitivity policy.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;T&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;T&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#minus(java.util.Set,java.util.Set)" class="member-name-link">minus</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;T&gt;&nbsp;set1,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;T&gt;&nbsp;set2)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a set of the elements which are in <code>set1</code> but not in
 <code>set2</code>, without modifying either.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#moveToHead(java.util.List,java.util.function.Predicate)" class="member-name-link">moveToHead</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends E&gt;&nbsp;terms,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/Predicate.html" title="class or interface in java.util.function" class="external-link">Predicate</a>&lt;? super E&gt;&nbsp;predicate)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a list with any elements for which the predicate is true moved to
 the head of the list.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/RuntimeException.html" title="class or interface in java.lang" class="external-link">RuntimeException</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#needToImplement(java.lang.Object)" class="member-name-link">needToImplement</a><wbr>(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;o)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/RuntimeException.html" title="class or interface in java.lang" class="external-link"><code>RuntimeException</code></a> indicating that a particular
 feature has not been implemented, but should be.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Error.html" title="class or interface in java.lang" class="external-link">Error</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#newInternal()" class="member-name-link">newInternal</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Throw new <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/AssertionError.html" title="class or interface in java.lang" class="external-link"><code>AssertionError</code></a></div>
</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Error.html" title="class or interface in java.lang" class="external-link">Error</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#newInternal(java.lang.String)" class="member-name-link">newInternal</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Throw new <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/AssertionError.html" title="class or interface in java.lang" class="external-link"><code>AssertionError</code></a></div>
</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Error.html" title="class or interface in java.lang" class="external-link">Error</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#newInternal(java.lang.Throwable)" class="member-name-link">newInternal</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Throwable.html" title="class or interface in java.lang" class="external-link">Throwable</a>&nbsp;e)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Throw new <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/RuntimeException.html" title="class or interface in java.lang" class="external-link"><code>RuntimeException</code></a> if checked; throw raw
 exception if unchecked or <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Error.html" title="class or interface in java.lang" class="external-link"><code>Error</code></a></div>
</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Error.html" title="class or interface in java.lang" class="external-link">Error</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#newInternal(java.lang.Throwable,java.lang.String)" class="member-name-link">newInternal</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Throwable.html" title="class or interface in java.lang" class="external-link">Throwable</a>&nbsp;e,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Throw new <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/AssertionError.html" title="class or interface in java.lang" class="external-link"><code>AssertionError</code></a> if applicable;
 or <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/RuntimeException.html" title="class or interface in java.lang" class="external-link"><code>RuntimeException</code></a> if e is checked;
 or raw exception if e is unchecked or <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Error.html" title="class or interface in java.lang" class="external-link"><code>Error</code></a>.</div>
</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#nLogM(double,double)" class="member-name-link">nLogM</a><wbr>(double&nbsp;n,
 double&nbsp;m)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Computes <code>nlog(m)</code> using the natural logarithm (or <code>
 n</code> if <code>m &lt; <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Math.html#E" title="class or interface in java.lang" class="external-link"><code>Math.E</code></a></code>, so the result is never
 negative.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static double</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#nLogN(double)" class="member-name-link">nLogN</a><wbr>(double&nbsp;d)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Computes <code>nlogn(n)</code> using the natural logarithm (or <code>
 n</code> if <code>n &lt; <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Math.html#E" title="class or interface in java.lang" class="external-link"><code>Math.E</code></a></code>, so the result is never
 negative.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;T&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;T&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#orEmpty(java.lang.Iterable)" class="member-name-link">orEmpty</a><wbr>(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;T&gt;&nbsp;v0)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="Pair.html" title="class in org.apache.calcite.util">Pair</a>&lt;E,<wbr>E&gt;&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#pairs(java.util.List)" class="member-name-link">pairs</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Given a list with N elements
 [e<sub>0</sub>, e<sub>1</sub>, ..., e<sub>N-1</sub>]
 (where N is even), returns a list of the N / 2 elements
 [ (e<sub>0</sub>, e<sub>1</sub>),
 (e<sub>2</sub>, e<sub>3</sub>), ...</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Locale.html" title="class or interface in java.util" class="external-link">Locale</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#parseLocale(java.lang.String)" class="member-name-link">parseLocale</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;localeString)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Parses a locale string.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#permAssert(boolean,java.lang.String)" class="member-name-link">permAssert</a><wbr>(boolean&nbsp;b,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;description)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use <code>Preconditions.checkArgument(boolean)</code></div>
</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#post(boolean,java.lang.String)" class="member-name-link">post</a><wbr>(boolean&nbsp;b,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;description)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use <code>Preconditions.checkArgument(boolean)</code>
 or <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Objects.html#requireNonNull(T)" title="class or interface in java.util" class="external-link"><code>Objects.requireNonNull(Object)</code></a></div>
</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#pre(boolean,java.lang.String)" class="member-name-link">pre</a><wbr>(boolean&nbsp;b,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;description)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use <code>Preconditions.checkArgument(boolean)</code>
 or <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Objects.html#requireNonNull(T)" title="class or interface in java.util" class="external-link"><code>Objects.requireNonNull(Object)</code></a></div>
</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#print(java.io.PrintWriter,java.lang.Object,int)" class="member-name-link">print</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/io/PrintWriter.html" title="class or interface in java.io" class="external-link">PrintWriter</a>&nbsp;pw,
 @Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;o,
 int&nbsp;indent)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#print(java.io.PrintWriter,java.lang.Object)" class="member-name-link">print</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/io/PrintWriter.html" title="class or interface in java.io" class="external-link">PrintWriter</a>&nbsp;pw,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;o)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Prints an object using reflection.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/StringBuilder.html" title="class or interface in java.lang" class="external-link">StringBuilder</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#printIterable(java.lang.StringBuilder,java.lang.Iterable)" class="member-name-link">printIterable</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/StringBuilder.html" title="class or interface in java.lang" class="external-link">StringBuilder</a>&nbsp;sb,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;E&gt;&nbsp;iterable)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Prints a collection of elements to a StringBuilder, in the same format as
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/AbstractCollection.html#toString()" title="class or interface in java.util" class="external-link"><code>AbstractCollection.toString()</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#printJavaString(java.lang.Appendable,java.lang.String,boolean)" class="member-name-link">printJavaString</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Appendable.html" title="class or interface in java.lang" class="external-link">Appendable</a>&nbsp;appendable,
 @Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 boolean&nbsp;nullMeansNull)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Prints a string, enclosing in double quotes (") and escaping if
 necessary.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/StringBuilder.html" title="class or interface in java.lang" class="external-link">StringBuilder</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#printList(java.lang.StringBuilder,int,java.util.function.ObjIntConsumer)" class="member-name-link">printList</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/StringBuilder.html" title="class or interface in java.lang" class="external-link">StringBuilder</a>&nbsp;sb,
 int&nbsp;elementCount,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/ObjIntConsumer.html" title="class or interface in java.util.function" class="external-link">ObjIntConsumer</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/StringBuilder.html" title="class or interface in java.lang" class="external-link">StringBuilder</a>&gt;&nbsp;consumer)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Prints a set of elements to a StringBuilder, in the same format same as
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/AbstractCollection.html#toString()" title="class or interface in java.util" class="external-link"><code>AbstractCollection.toString()</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#println(java.io.PrintWriter,java.lang.Object)" class="member-name-link">println</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/io/PrintWriter.html" title="class or interface in java.io" class="external-link">PrintWriter</a>&nbsp;pw,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;o)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/io/PrintWriter.html" title="class or interface in java.io" class="external-link">PrintWriter</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#printWriter(java.io.File)" class="member-name-link">printWriter</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/io/File.html" title="class or interface in java.io" class="external-link">File</a>&nbsp;file)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a <a href="https://docs.oracle.com/javase/9/docs/api/java/io/PrintWriter.html" title="class or interface in java.io" class="external-link"><code>PrintWriter</code></a> to a given file using UTF-8
 character set.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/io/PrintWriter.html" title="class or interface in java.io" class="external-link">PrintWriter</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#printWriter(java.io.OutputStream)" class="member-name-link">printWriter</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/io/OutputStream.html" title="class or interface in java.io" class="external-link">OutputStream</a>&nbsp;out)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a <a href="https://docs.oracle.com/javase/9/docs/api/java/io/PrintWriter.html" title="class or interface in java.io" class="external-link"><code>PrintWriter</code></a> to a given output stream using UTF-8
 character set.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#quotientList(java.util.List,int,int)" class="member-name-link">quotientList</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list,
 int&nbsp;n,
 int&nbsp;k)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a list that returns every <code>n</code>th element of a list,
 starting at element <code>k</code>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#range(int)" class="member-name-link">range</a><wbr>(int&nbsp;end)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#range(int,int)" class="member-name-link">range</a><wbr>(int&nbsp;start,
 int&nbsp;end)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#readAllAsString(java.io.Reader)" class="member-name-link">readAllAsString</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/io/Reader.html" title="class or interface in java.io" class="external-link">Reader</a>&nbsp;reader)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/io/BufferedReader.html" title="class or interface in java.io" class="external-link">BufferedReader</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#reader(java.io.File)" class="member-name-link">reader</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/io/File.html" title="class or interface in java.io" class="external-link">File</a>&nbsp;file)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a <a href="https://docs.oracle.com/javase/9/docs/api/java/io/BufferedReader.html" title="class or interface in java.io" class="external-link"><code>BufferedReader</code></a> to read a given file using UTF-8
 character set.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/io/BufferedReader.html" title="class or interface in java.io" class="external-link">BufferedReader</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#reader(java.io.InputStream)" class="member-name-link">reader</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;in)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Creates a <a href="https://docs.oracle.com/javase/9/docs/api/java/io/BufferedReader.html" title="class or interface in java.io" class="external-link"><code>BufferedReader</code></a> to a given input stream using UTF-8
 character set.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#replace(java.lang.String,java.lang.String,java.lang.String)" class="member-name-link">replace</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;find,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;replace)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Replaces every occurrence of <code>find</code> in <code>s</code> with
 <code>replace</code>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#rpad(java.lang.String,int)" class="member-name-link">rpad</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 int&nbsp;len)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use <code>Spaces.padRight(String, int)</code></div>
</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#rtrim(java.lang.String)" class="member-name-link">rtrim</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#select(java.util.List,java.util.List)" class="member-name-link">select</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;ordinals)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a view of a list, picking the elements of a list with the given
 set of ordinals.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;T&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#sepList(java.util.List,java.lang.String)" class="member-name-link">sepList</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;T&gt;&nbsp;list,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;sep)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a list of a string, with a given separator between elements.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#skip(java.util.List)" class="member-name-link">skip</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns all but the first element of a list.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#skip(java.util.List,int)" class="member-name-link">skip</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list,
 int&nbsp;fromIndex)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns all but the first <code>n</code> elements of a list.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#skipLast(java.util.List)" class="member-name-link">skipLast</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns every element of a list but its last element.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#skipLast(java.util.List,int)" class="member-name-link">skipLast</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list,
 int&nbsp;n)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns every element of a list but its last <code>n</code> elements.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#squelchConnection(java.sql.Connection)" class="member-name-link">squelchConnection</a><wbr>(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/sql/Connection.html" title="class or interface in java.sql" class="external-link">Connection</a>&nbsp;connection)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#squelchJar(java.util.jar.JarFile)" class="member-name-link">squelchJar</a><wbr>(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/util/jar/JarFile.html" title="class or interface in java.util.jar" class="external-link">JarFile</a>&nbsp;jar)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#squelchReader(java.io.Reader)" class="member-name-link">squelchReader</a><wbr>(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/io/Reader.html" title="class or interface in java.io" class="external-link">Reader</a>&nbsp;reader)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#squelchStmt(java.sql.Statement)" class="member-name-link">squelchStmt</a><wbr>(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/sql/Statement.html" title="class or interface in java.sql" class="external-link">Statement</a>&nbsp;stmt)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#squelchStream(java.io.InputStream)" class="member-name-link">squelchStream</a><wbr>(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#squelchStream(java.io.OutputStream)" class="member-name-link">squelchStream</a><wbr>(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/io/OutputStream.html" title="class or interface in java.io" class="external-link">OutputStream</a>&nbsp;stream)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#squelchWriter(java.io.Writer)" class="member-name-link">squelchWriter</a><wbr>(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/io/Writer.html" title="class or interface in java.io" class="external-link">Writer</a>&nbsp;writer)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E&gt;&nbsp;boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#startsWith(java.util.List,java.util.List)" class="member-name-link">startsWith</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list0,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list1)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns whether one list is a prefix of another.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#stringToList(java.lang.String)" class="member-name-link">stringToList</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#stripDoubleQuotes(java.lang.String)" class="member-name-link">stripDoubleQuotes</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts double-quoted Java strings to their contents.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#swallow(java.lang.Throwable,org.slf4j.Logger)" class="member-name-link">swallow</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Throwable.html" title="class or interface in java.lang" class="external-link">Throwable</a>&nbsp;e,
 @Nullable org.slf4j.Logger&nbsp;logger)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Records that an exception has been caught but will not be re-thrown.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/RuntimeException.html" title="class or interface in java.lang" class="external-link">RuntimeException</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#throwAsRuntime(java.lang.String,java.lang.Throwable)" class="member-name-link">throwAsRuntime</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;message,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Throwable.html" title="class or interface in java.lang" class="external-link">Throwable</a>&nbsp;throwable)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">This method rethrows input throwable as is (if its unchecked) with an extra message or
 wraps it with <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/RuntimeException.html" title="class or interface in java.lang" class="external-link"><code>RuntimeException</code></a> and throws.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/RuntimeException.html" title="class or interface in java.lang" class="external-link">RuntimeException</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#throwAsRuntime(java.lang.Throwable)" class="member-name-link">throwAsRuntime</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Throwable.html" title="class or interface in java.lang" class="external-link">Throwable</a>&nbsp;throwable)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">This method rethrows input throwable as is (if its unchecked) or
 wraps it with <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/RuntimeException.html" title="class or interface in java.lang" class="external-link"><code>RuntimeException</code></a> and throws.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#throwIfUnchecked(java.lang.Throwable)" class="member-name-link">throwIfUnchecked</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Throwable.html" title="class or interface in java.lang" class="external-link">Throwable</a>&nbsp;throwable)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">As <code>Throwables</code><code>.throwIfUnchecked(Throwable)</code>,
 which was introduced in Guava 20,
 but we don't require Guava version 20 yet.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;T&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/util/stream/Collector.html" title="class or interface in java.util.stream" class="external-link">Collector</a>&lt;T,<wbr>com.google.common.collect.ImmutableList.Builder&lt;T&gt;,<wbr>com.google.common.collect.ImmutableList&lt;T&gt;&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toImmutableList()" class="member-name-link">toImmutableList</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns a <code>Collector</code> that accumulates the input elements into a
 Guava <code>ImmutableList</code> via a <code>ImmutableList.Builder</code>.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toJavaId(java.lang.String,int)" class="member-name-link">toJavaId</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 int&nbsp;ordinal)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts an arbitrary string into a string suitable for use as a Java
 identifier.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#tokenize(java.lang.String,java.lang.String)" class="member-name-link">tokenize</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;delim)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a string into tokens.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toLinux(java.lang.String)" class="member-name-link">toLinux</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static &lt;T&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;T&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#toList(java.util.Iterator)" class="member-name-link">toList</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/Iterator.html" title="class or interface in java.util" class="external-link">Iterator</a>&lt;T&gt;&nbsp;iter)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toMap(java.util.Properties)" class="member-name-link">toMap</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/Properties.html" title="class or interface in java.util" class="external-link">Properties</a>&nbsp;properties)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Properties.html" title="class or interface in java.util" class="external-link"><code>Properties</code></a> object to a <code><a href="https://docs.oracle.com/javase/9/docs/api/java/util/Map.html" title="class or interface in java.util" class="external-link"><code>Map</code></a>&lt;String,
 String&gt;</code>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toPosix(java.util.TimeZone,boolean)" class="member-name-link">toPosix</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/TimeZone.html" title="class or interface in java.util" class="external-link">TimeZone</a>&nbsp;tz,
 boolean&nbsp;verbose)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts a Java timezone to POSIX format, so that the boost C++ library
 can instantiate timezone objects.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toScientificNotation(java.math.BigDecimal)" class="member-name-link">toScientificNotation</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;bd)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Formats a <a href="https://docs.oracle.com/javase/9/docs/api/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link"><code>BigDecimal</code></a> value to a string in scientific notation For
 example<br>

 
 A value of 0.00001234 would be formated as <code>1.234E-5</code>
 A value of 100000.00 would be formated as <code>1.00E5</code>
 A value of 100 (scale zero) would be formated as
     <code>1E2</code>
 </div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;T&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toString(java.lang.Iterable,java.lang.String,java.lang.String,java.lang.String)" class="member-name-link">toString</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;T&gt;&nbsp;iterable,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;start,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;sep,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;end)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Converts an iterable to a string.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/RuntimeException.html" title="class or interface in java.lang" class="external-link">RuntimeException</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#toUnchecked(java.lang.Exception)" class="member-name-link">toUnchecked</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Exception.html" title="class or interface in java.lang" class="external-link">Exception</a>&nbsp;e)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Wraps an exception with <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/RuntimeException.html" title="class or interface in java.lang" class="external-link"><code>RuntimeException</code></a> and return it.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code>static <a href="https://docs.oracle.com/javase/9/docs/api/java/net/URL.html" title="class or interface in java.net" class="external-link">URL</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6"><code><a href="#toURL(java.io.File)" class="member-name-link">toURL</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/io/File.html" title="class or interface in java.io" class="external-link">File</a>&nbsp;file)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4 method-summary-table-tab6">
<div class="block"><span class="deprecated-label">Deprecated.</span></div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;F,<wbr>
T&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;T&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#transform(java.lang.Iterable,java.util.function.Function)" class="member-name-link">transform</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;? extends F&gt;&nbsp;iterable,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/Function.html" title="class or interface in java.util.function" class="external-link">Function</a>&lt;? super F,<wbr>? extends T&gt;&nbsp;function)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Transforms an iterable, applying a function to each element.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;F,<wbr>
T&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/util/Iterator.html" title="class or interface in java.util" class="external-link">Iterator</a>&lt;T&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#transform(java.util.Iterator,java.util.function.Function)" class="member-name-link">transform</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/Iterator.html" title="class or interface in java.util" class="external-link">Iterator</a>&lt;? extends F&gt;&nbsp;iterator,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/Function.html" title="class or interface in java.util.function" class="external-link">Function</a>&lt;? super F,<wbr>? extends T&gt;&nbsp;function)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Transforms an iterator.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;F,<wbr>
T&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;T&gt;</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#transform(java.util.List,java.util.function.Function)" class="member-name-link">transform</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends F&gt;&nbsp;list,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/Function.html" title="class or interface in java.util.function" class="external-link">Function</a>&lt;? super F,<wbr>? extends T&gt;&nbsp;function)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Transforms a list, applying a function to each element.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;F,<wbr>
T&gt;&nbsp;<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;T&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#transformIndexed(java.util.List,java.util.function.BiFunction)" class="member-name-link">transformIndexed</a><wbr>(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends F&gt;&nbsp;list,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/BiFunction.html" title="class or interface in java.util.function" class="external-link">BiFunction</a>&lt;? super F,<wbr><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>,<wbr>? extends T&gt;&nbsp;function)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Transforms a list, applying a function to each element, also passing in
 the element's index in the list.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static &lt;E extends <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Enum.html" title="class or interface in java.lang" class="external-link">Enum</a>&lt;E&gt;&gt;<br><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Error.html" title="class or interface in java.lang" class="external-link">Error</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#unexpected(E)" class="member-name-link">unexpected</a><wbr>(E&nbsp;value)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Returns an exception indicating that we didn't expect to find this
 enumeration here.</div>
</div>
</div>
</div>
</div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-java.lang.Object">Methods inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></h3>
<code><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#clone()" title="class or interface in java.lang" class="external-link">clone</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#equals(java.lang.Object)" title="class or interface in java.lang" class="external-link">equals</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#finalize()" title="class or interface in java.lang" class="external-link">finalize</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#getClass()" title="class or interface in java.lang" class="external-link">getClass</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#hashCode()" title="class or interface in java.lang" class="external-link">hashCode</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#notify()" title="class or interface in java.lang" class="external-link">notify</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#notifyAll()" title="class or interface in java.lang" class="external-link">notifyAll</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#toString()" title="class or interface in java.lang" class="external-link">toString</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#wait()" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#wait(long)" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html#wait(long,int)" title="class or interface in java.lang" class="external-link">wait</a></code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ============ FIELD DETAIL =========== -->
<li>
<section class="field-details" id="field-detail">
<h2>Field Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="LINE_SEPARATOR">
<h3>LINE_SEPARATOR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">LINE_SEPARATOR</span></div>
<div class="block">System-dependent newline character.

 <p>In general, you should not use this in expected results of tests.
 Expected results should be the expected result on Linux (or Mac OS) using
 '\n'. Apply <a href="#toLinux(java.lang.String)"><code>toLinux(String)</code></a> to Windows actual results, if
 necessary, to make them look like Linux actual.</p></div>
</section>
</li>
<li>
<section class="detail" id="FILE_SEPARATOR">
<h3>FILE_SEPARATOR</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">FILE_SEPARATOR</span></div>
<div class="block">System-dependent file separator, for example, "/" or "\."</div>
</section>
</li>
<li>
<section class="detail" id="FILE_TIMESTAMP_FORMAT">
<h3>FILE_TIMESTAMP_FORMAT</h3>
<div class="member-signature"><span class="modifiers">public static final</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">FILE_TIMESTAMP_FORMAT</span></div>
<div class="block">Datetime format string for generating a timestamp string to be used as
 part of a filename. Conforms to SimpleDateFormat conventions.</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list">
<li><a href="../../../../constant-values.html#org.apache.calcite.util.Util.FILE_TIMESTAMP_FORMAT">Constant Field Values</a></li>
</ul>
</dd>
</dl>
</section>
</li>
</ul>
</section>
</li>
<!-- ============ METHOD DETAIL ========== -->
<li>
<section class="method-details" id="method-detail">
<h2>Method Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="isSingleValue(org.apache.calcite.sql.SqlCall)">
<h3>isSingleValue</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isSingleValue</span><wbr><span class="parameters">(<a href="../sql/SqlCall.html" title="class in org.apache.calcite.sql">SqlCall</a>&nbsp;call)</span></div>
<div class="block">Does nothing with its argument. Returns whether it is ensured that
 the call produces a single value</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>call</code> - the expression to evaluate</dd>
<dt>Returns:</dt>
<dd>Whether it is ensured that the call produces a single value</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="discard(java.lang.Object)">
<h3>discard</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">discard</span><wbr><span class="parameters">(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;o)</span></div>
<div class="block">Does nothing with its argument. Call this method when you have a value
 you are not interested in, but you don't want the compiler to warn that
 you are not using it.</div>
</section>
</li>
<li>
<section class="detail" id="discard(int)">
<h3>discard</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">discard</span><wbr><span class="parameters">(int&nbsp;i)</span></div>
<div class="block">Does nothing with its argument. Call this method when you have a value
 you are not interested in, but you don't want the compiler to warn that
 you are not using it.</div>
</section>
</li>
<li>
<section class="detail" id="discard(boolean)">
<h3>discard</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">discard</span><wbr><span class="parameters">(boolean&nbsp;b)</span></div>
<div class="block">Does nothing with its argument. Call this method when you have a value
 you are not interested in, but you don't want the compiler to warn that
 you are not using it.</div>
</section>
</li>
<li>
<section class="detail" id="discard(double)">
<h3>discard</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">discard</span><wbr><span class="parameters">(double&nbsp;d)</span></div>
<div class="block">Does nothing with its argument. Call this method when you have a value
 you are not interested in, but you don't want the compiler to warn that
 you are not using it.</div>
</section>
</li>
<li>
<section class="detail" id="swallow(java.lang.Throwable,org.slf4j.Logger)">
<h3>swallow</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">swallow</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Throwable.html" title="class or interface in java.lang" class="external-link">Throwable</a>&nbsp;e,
 @Nullable org.slf4j.Logger&nbsp;logger)</span></div>
<div class="block">Records that an exception has been caught but will not be re-thrown. If
 the tracer is not null, logs the exception to the tracer.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>e</code> - Exception</dd>
<dd><code>logger</code> - If not null, logs exception to this logger</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="equalShallow(java.util.List,java.util.List)">
<h3>equalShallow</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;T&gt;</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">equalShallow</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends T&gt;&nbsp;list0,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends T&gt;&nbsp;list1)</span></div>
<div class="block">Returns whether two lists are equal to each other using shallow
 comparisons.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>list0</code> - First list</dd>
<dd><code>list1</code> - Second list</dd>
<dt>Returns:</dt>
<dd>Whether lists are same length and all of their elements are
 equal using <code>==</code> (may be null).</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="hash(int,int)">
<h3>hash</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">hash</span><wbr><span class="parameters">(int&nbsp;i,
 int&nbsp;j)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Objects.html#hash(java.lang.Object...)" title="class or interface in java.util" class="external-link"><code>Objects.hash(Object...)</code></a></div>
</div>
<div class="block">Combines two integers into a hash code.</div>
</section>
</li>
<li>
<section class="detail" id="hash(int,java.lang.Object)">
<h3>hash</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">hash</span><wbr><span class="parameters">(int&nbsp;h,
 @Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;o)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Objects.html#hash(java.lang.Object...)" title="class or interface in java.util" class="external-link"><code>Objects.hash(Object...)</code></a></div>
</div>
<div class="block">Computes a hash code from an existing hash code and an object (which may
 be null).</div>
</section>
</li>
<li>
<section class="detail" id="hashArray(int,java.lang.Object[])">
<h3>hashArray</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">hashArray</span><wbr><span class="parameters">(int&nbsp;h,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>[]&nbsp;a)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Objects.html#hash(java.lang.Object...)" title="class or interface in java.util" class="external-link"><code>Objects.hash(Object...)</code></a></div>
</div>
<div class="block">Computes a hash code from an existing hash code and an array of objects
 (which may be null).</div>
</section>
</li>
<li>
<section class="detail" id="hashCode(double)">
<h3>hashCode</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">hashCode</span><wbr><span class="parameters">(double&nbsp;v)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use <a href="../runtime/Utilities.html#hashCode(double)"><code>Utilities.hashCode(double)</code></a></div>
</div>
<div class="block">Computes the hash code of a <code>double</code> value. Equivalent to
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Double.html" title="class or interface in java.lang" class="external-link"><code>Double</code></a><code>.hashCode(double)</code>, but that method was only
 introduced in JDK 1.8.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>v</code> - Value</dd>
<dt>Returns:</dt>
<dd>Hash code</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="minus(java.util.Set,java.util.Set)">
<h3>minus</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;T&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;T&gt;</span>&nbsp;<span class="element-name">minus</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;T&gt;&nbsp;set1,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Set.html" title="class or interface in java.util" class="external-link">Set</a>&lt;T&gt;&nbsp;set2)</span></div>
<div class="block">Returns a set of the elements which are in <code>set1</code> but not in
 <code>set2</code>, without modifying either.</div>
</section>
</li>
<li>
<section class="detail" id="nLogN(double)">
<h3>nLogN</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">nLogN</span><wbr><span class="parameters">(double&nbsp;d)</span></div>
<div class="block">Computes <code>nlogn(n)</code> using the natural logarithm (or <code>
 n</code> if <code>n &lt; <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Math.html#E" title="class or interface in java.lang" class="external-link"><code>Math.E</code></a></code>, so the result is never
 negative.</div>
</section>
</li>
<li>
<section class="detail" id="nLogM(double,double)">
<h3>nLogM</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">nLogM</span><wbr><span class="parameters">(double&nbsp;n,
 double&nbsp;m)</span></div>
<div class="block">Computes <code>nlog(m)</code> using the natural logarithm (or <code>
 n</code> if <code>m &lt; <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Math.html#E" title="class or interface in java.lang" class="external-link"><code>Math.E</code></a></code>, so the result is never
 negative.</div>
</section>
</li>
<li>
<section class="detail" id="print(java.io.PrintWriter,java.lang.Object)">
<h3>print</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">print</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/io/PrintWriter.html" title="class or interface in java.io" class="external-link">PrintWriter</a>&nbsp;pw,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;o)</span></div>
<div class="block">Prints an object using reflection. We can handle <code>null</code>;
 arrays of objects and primitive values; for regular objects, we print all
 public fields.</div>
</section>
</li>
<li>
<section class="detail" id="print(java.io.PrintWriter,java.lang.Object,int)">
<h3>print</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">print</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/io/PrintWriter.html" title="class or interface in java.io" class="external-link">PrintWriter</a>&nbsp;pw,
 @Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;o,
 int&nbsp;indent)</span></div>
</section>
</li>
<li>
<section class="detail" id="printJavaString(java.lang.Appendable,java.lang.String,boolean)">
<h3>printJavaString</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">printJavaString</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Appendable.html" title="class or interface in java.lang" class="external-link">Appendable</a>&nbsp;appendable,
 @Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 boolean&nbsp;nullMeansNull)</span></div>
<div class="block">Prints a string, enclosing in double quotes (") and escaping if
 necessary. For example, <code>printDoubleQuoted(w,"x\"y",false)</code>
 prints <code>"x\"y"</code>.

 <p>The appendable where the value is printed must not incur I/O operations. This method is
 not meant to be used for writing the values to permanent storage.</p></div>
<dl class="notes">
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/IllegalStateException.html" title="class or interface in java.lang" class="external-link">IllegalStateException</a></code> - if the print to the specified appendable fails due to I/O</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="println(java.io.PrintWriter,java.lang.Object)">
<h3>println</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">println</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/io/PrintWriter.html" title="class or interface in java.io" class="external-link">PrintWriter</a>&nbsp;pw,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;o)</span></div>
</section>
</li>
<li>
<section class="detail" id="toScientificNotation(java.math.BigDecimal)">
<h3>toScientificNotation</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">toScientificNotation</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link">BigDecimal</a>&nbsp;bd)</span></div>
<div class="block">Formats a <a href="https://docs.oracle.com/javase/9/docs/api/java/math/BigDecimal.html" title="class or interface in java.math" class="external-link"><code>BigDecimal</code></a> value to a string in scientific notation For
 example<br>

 <ul>
 <li>A value of 0.00001234 would be formated as <code>1.234E-5</code></li>
 <li>A value of 100000.00 would be formated as <code>1.00E5</code></li>
 <li>A value of 100 (scale zero) would be formated as
     <code>1E2</code></li>
 </ul>

 <p>If <code>bd</code> has a precision higher than 20, this method will
 truncate the output string to have a precision of 20 (no rounding will be
 done, just a truncate).</div>
</section>
</li>
<li>
<section class="detail" id="replace(java.lang.String,java.lang.String,java.lang.String)">
<h3>replace</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">replace</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;find,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;replace)</span></div>
<div class="block">Replaces every occurrence of <code>find</code> in <code>s</code> with
 <code>replace</code>.</div>
</section>
</li>
<li>
<section class="detail" id="toURL(java.io.File)">
<h3>toURL</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/net/URL.html" title="class or interface in java.net" class="external-link">URL</a></span>&nbsp;<span class="element-name">toURL</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/io/File.html" title="class or interface in java.io" class="external-link">File</a>&nbsp;file)</span>
                 throws <span class="exceptions"><a href="https://docs.oracle.com/javase/9/docs/api/java/net/MalformedURLException.html" title="class or interface in java.net" class="external-link">MalformedURLException</a></span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
<div class="block">Creates a file-protocol URL for the given file.</div>
<dl class="notes">
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/javase/9/docs/api/java/net/MalformedURLException.html" title="class or interface in java.net" class="external-link">MalformedURLException</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getFileTimestamp()">
<h3>getFileTimestamp</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getFileTimestamp</span>()</div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
<div class="block">Gets a timestamp string for use in file names. The generated timestamp
 string reflects the current time.</div>
</section>
</li>
<li>
<section class="detail" id="stripDoubleQuotes(java.lang.String)">
<h3>stripDoubleQuotes</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">stripDoubleQuotes</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;value)</span></div>
<div class="block">Converts double-quoted Java strings to their contents. For example,
 <code>"foo\"bar"</code> becomes <code>foo"bar</code>.</div>
</section>
</li>
<li>
<section class="detail" id="toJavaId(java.lang.String,int)">
<h3>toJavaId</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">toJavaId</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 int&nbsp;ordinal)</span></div>
<div class="block">Converts an arbitrary string into a string suitable for use as a Java
 identifier.

 <p>The mapping is one-to-one (that is, distinct strings will produce
 distinct java identifiers). The mapping is also reversible, but the
 inverse mapping is not implemented.</p>

 <p>A valid Java identifier must start with a Unicode letter, underscore,
 or dollar sign ($). The other characters, if any, can be a Unicode
 letter, underscore, dollar sign, or digit.</p>

 <p>This method uses an algorithm similar to URL encoding. Valid
 characters are unchanged; invalid characters are converted to an
 underscore followed by the hex code of the character; and underscores are
 doubled.</p>

 <p>Examples:

 <ul>
 <li><code>toJavaId("foo")</code> returns <code>"foo"</code>
 <li><code>toJavaId("foo bar")</code> returns <code>"foo_20_bar"</code>
 <li><code>toJavaId("foo_bar")</code> returns <code>"foo__bar"</code>
 <li><code>toJavaId("0bar")</code> returns <code>"_40_bar"</code> (digits
 are illegal as a prefix)
 <li><code>toJavaId("foo0bar")</code> returns <code>"foo0bar"</code>
 </ul></div>
</section>
</li>
<li>
<section class="detail" id="isValidJavaIdentifier(java.lang.String)">
<h3>isValidJavaIdentifier</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isValidJavaIdentifier</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</span></div>
<div class="block">Returns true when input string is a valid Java identifier.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>s</code> - input string</dd>
<dt>Returns:</dt>
<dd>true when input string is a valid Java identifier</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="toLinux(java.lang.String)">
<h3>toLinux</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">toLinux</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</span></div>
</section>
</li>
<li>
<section class="detail" id="toList(java.util.Iterator)">
<h3>toList</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;T&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;T&gt;</span>&nbsp;<span class="element-name">toList</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/Iterator.html" title="class or interface in java.util" class="external-link">Iterator</a>&lt;T&gt;&nbsp;iter)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
<div class="block">Materializes the results of a <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Iterator.html" title="class or interface in java.util" class="external-link"><code>Iterator</code></a> as a
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link"><code>List</code></a>.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>iter</code> - iterator to materialize</dd>
<dt>Returns:</dt>
<dd>materialized list</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isNullOrEmpty(java.lang.String)">
<h3>isNullOrEmpty</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isNullOrEmpty</span><wbr><span class="parameters">(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</span></div>
<div class="block">Returns whether s == null or if s.length() == 0.</div>
</section>
</li>
<li>
<section class="detail" id="commaList(java.util.List)">
<h3>commaList</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;T&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">commaList</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;T&gt;&nbsp;list)</span></div>
<div class="block">Converts a list of a string, with commas between elements.

 <p>For example,
 <code>commaList(Arrays.asList({"a", "b"}))</code>
 returns "a, b".</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>list</code> - List</dd>
<dt>Returns:</dt>
<dd>String representation of string</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="sepList(java.util.List,java.lang.String)">
<h3>sepList</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;T&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">sepList</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;T&gt;&nbsp;list,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;sep)</span></div>
<div class="block">Converts a list of a string, with a given separator between elements.</div>
</section>
</li>
<li>
<section class="detail" id="printIterable(java.lang.StringBuilder,java.lang.Iterable)">
<h3>printIterable</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/StringBuilder.html" title="class or interface in java.lang" class="external-link">StringBuilder</a></span>&nbsp;<span class="element-name">printIterable</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/StringBuilder.html" title="class or interface in java.lang" class="external-link">StringBuilder</a>&nbsp;sb,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;E&gt;&nbsp;iterable)</span></div>
<div class="block">Prints a collection of elements to a StringBuilder, in the same format as
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/AbstractCollection.html#toString()" title="class or interface in java.util" class="external-link"><code>AbstractCollection.toString()</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="printList(java.lang.StringBuilder,int,java.util.function.ObjIntConsumer)">
<h3>printList</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/StringBuilder.html" title="class or interface in java.lang" class="external-link">StringBuilder</a></span>&nbsp;<span class="element-name">printList</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/StringBuilder.html" title="class or interface in java.lang" class="external-link">StringBuilder</a>&nbsp;sb,
 int&nbsp;elementCount,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/ObjIntConsumer.html" title="class or interface in java.util.function" class="external-link">ObjIntConsumer</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/StringBuilder.html" title="class or interface in java.lang" class="external-link">StringBuilder</a>&gt;&nbsp;consumer)</span></div>
<div class="block">Prints a set of elements to a StringBuilder, in the same format same as
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/AbstractCollection.html#toString()" title="class or interface in java.util" class="external-link"><code>AbstractCollection.toString()</code></a>.

 <p>The 'set' is represented by the number of elements and an action to
 perform for each element.

 <p>This method can be a very efficient way to convert a structure to a
 string, because the components can write directly to the StringBuilder
 rather than constructing intermediate strings.</div>
<dl class="notes">
<dt>See Also:</dt>
<dd>
<ul class="see-list-long">
<li><a href="../linq4j/function/Functions.html#generate(int,java.util.function.IntFunction)"><code>Functions.generate(int, java.util.function.IntFunction&lt;E&gt;)</code></a></li>
</ul>
</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getDefaultCharset()">
<h3>getDefaultCharset</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/nio/charset/Charset.html" title="class or interface in java.nio.charset" class="external-link">Charset</a></span>&nbsp;<span class="element-name">getDefaultCharset</span>()</div>
<div class="block">Returns the <a href="https://docs.oracle.com/javase/9/docs/api/java/nio/charset/Charset.html" title="class or interface in java.nio.charset" class="external-link"><code>Charset</code></a> object representing the value of
 <a href="../config/CalciteSystemProperty.html#DEFAULT_CHARSET"><code>CalciteSystemProperty.DEFAULT_CHARSET</code></a>.</div>
<dl class="notes">
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/javase/9/docs/api/java/nio/charset/IllegalCharsetNameException.html" title="class or interface in java.nio.charset" class="external-link">IllegalCharsetNameException</a></code> - If the given charset
                                                      name is illegal</dd>
<dd><code><a href="https://docs.oracle.com/javase/9/docs/api/java/nio/charset/UnsupportedCharsetException.html" title="class or interface in java.nio.charset" class="external-link">UnsupportedCharsetException</a></code> - If no support for
                                                      the named charset is
                                                      available in this
                                                      instance of the Java
                                                      virtual machine</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="newInternal()">
<h3>newInternal</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Error.html" title="class or interface in java.lang" class="external-link">Error</a></span>&nbsp;<span class="element-name">newInternal</span>()</div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Throw new <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/AssertionError.html" title="class or interface in java.lang" class="external-link"><code>AssertionError</code></a></div>
</div>
</section>
</li>
<li>
<section class="detail" id="newInternal(java.lang.String)">
<h3>newInternal</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Error.html" title="class or interface in java.lang" class="external-link">Error</a></span>&nbsp;<span class="element-name">newInternal</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Throw new <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/AssertionError.html" title="class or interface in java.lang" class="external-link"><code>AssertionError</code></a></div>
</div>
</section>
</li>
<li>
<section class="detail" id="newInternal(java.lang.Throwable)">
<h3>newInternal</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Error.html" title="class or interface in java.lang" class="external-link">Error</a></span>&nbsp;<span class="element-name">newInternal</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Throwable.html" title="class or interface in java.lang" class="external-link">Throwable</a>&nbsp;e)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Throw new <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/RuntimeException.html" title="class or interface in java.lang" class="external-link"><code>RuntimeException</code></a> if checked; throw raw
 exception if unchecked or <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Error.html" title="class or interface in java.lang" class="external-link"><code>Error</code></a></div>
</div>
</section>
</li>
<li>
<section class="detail" id="newInternal(java.lang.Throwable,java.lang.String)">
<h3>newInternal</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Error.html" title="class or interface in java.lang" class="external-link">Error</a></span>&nbsp;<span class="element-name">newInternal</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Throwable.html" title="class or interface in java.lang" class="external-link">Throwable</a>&nbsp;e,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Throw new <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/AssertionError.html" title="class or interface in java.lang" class="external-link"><code>AssertionError</code></a> if applicable;
 or <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/RuntimeException.html" title="class or interface in java.lang" class="external-link"><code>RuntimeException</code></a> if e is checked;
 or raw exception if e is unchecked or <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Error.html" title="class or interface in java.lang" class="external-link"><code>Error</code></a>.</div>
</div>
</section>
</li>
<li>
<section class="detail" id="throwIfUnchecked(java.lang.Throwable)">
<h3>throwIfUnchecked</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">throwIfUnchecked</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Throwable.html" title="class or interface in java.lang" class="external-link">Throwable</a>&nbsp;throwable)</span></div>
<div class="block">As <code>Throwables</code><code>.throwIfUnchecked(Throwable)</code>,
 which was introduced in Guava 20,
 but we don't require Guava version 20 yet.</div>
</section>
</li>
<li>
<section class="detail" id="throwAsRuntime(java.lang.Throwable)">
<h3>throwAsRuntime</h3>
<div class="member-signature"><span class="annotations">@API(since="1.26",
     status=EXPERIMENTAL)
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/RuntimeException.html" title="class or interface in java.lang" class="external-link">RuntimeException</a></span>&nbsp;<span class="element-name">throwAsRuntime</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Throwable.html" title="class or interface in java.lang" class="external-link">Throwable</a>&nbsp;throwable)</span></div>
<div class="block">This method rethrows input throwable as is (if its unchecked) or
 wraps it with <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/RuntimeException.html" title="class or interface in java.lang" class="external-link"><code>RuntimeException</code></a> and throws.
 <p>The typical usage would be <code>throw throwAsRuntime(...)</code>, where <code>throw</code> statement
 is needed so Java compiler knows the execution stops at that line.</p></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>throwable</code> - input throwable</dd>
<dt>Returns:</dt>
<dd>the method never returns, it always throws an unchecked exception</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="throwAsRuntime(java.lang.String,java.lang.Throwable)">
<h3>throwAsRuntime</h3>
<div class="member-signature"><span class="annotations">@API(since="1.26",
     status=EXPERIMENTAL)
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/RuntimeException.html" title="class or interface in java.lang" class="external-link">RuntimeException</a></span>&nbsp;<span class="element-name">throwAsRuntime</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;message,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Throwable.html" title="class or interface in java.lang" class="external-link">Throwable</a>&nbsp;throwable)</span></div>
<div class="block">This method rethrows input throwable as is (if its unchecked) with an extra message or
 wraps it with <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/RuntimeException.html" title="class or interface in java.lang" class="external-link"><code>RuntimeException</code></a> and throws.
 <p>The typical usage would be <code>throw throwAsRuntime(...)</code>, where <code>throw</code> statement
 is needed so Java compiler knows the execution stops at that line.</p></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>throwable</code> - input throwable</dd>
<dt>Returns:</dt>
<dd>the method never returns, it always throws an unchecked exception</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="toUnchecked(java.lang.Exception)">
<h3>toUnchecked</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/RuntimeException.html" title="class or interface in java.lang" class="external-link">RuntimeException</a></span>&nbsp;<span class="element-name">toUnchecked</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Exception.html" title="class or interface in java.lang" class="external-link">Exception</a>&nbsp;e)</span></div>
<div class="block">Wraps an exception with <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/RuntimeException.html" title="class or interface in java.lang" class="external-link"><code>RuntimeException</code></a> and return it.
 If the exception is already an instance of RuntimeException,
 returns it directly.</div>
</section>
</li>
<li>
<section class="detail" id="causeOrSelf(java.lang.Throwable)">
<h3>causeOrSelf</h3>
<div class="member-signature"><span class="annotations">@API(since="1.26",
     status=EXPERIMENTAL)
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Throwable.html" title="class or interface in java.lang" class="external-link">Throwable</a></span>&nbsp;<span class="element-name">causeOrSelf</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Throwable.html" title="class or interface in java.lang" class="external-link">Throwable</a>&nbsp;throwable)</span></div>
<div class="block">Returns cause of the given throwable if it is non-null or the throwable itself.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>throwable</code> - input throwable</dd>
<dt>Returns:</dt>
<dd>cause of the given throwable if it is non-null or the throwable itself</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getMessages(java.lang.Throwable)">
<h3>getMessages</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getMessages</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Throwable.html" title="class or interface in java.lang" class="external-link">Throwable</a>&nbsp;t)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
<div class="block">Retrieves messages in a exception and writes them to a string. In the
 string returned, each message will appear on a different line.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>a non-null string containing all messages of the exception</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getStackTrace(java.lang.Throwable)">
<h3>getStackTrace</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getStackTrace</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Throwable.html" title="class or interface in java.lang" class="external-link">Throwable</a>&nbsp;t)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use <code>Throwables.getStackTraceAsString(Throwable)</code></div>
</div>
<div class="block">Returns the stack trace of a throwable. Called from native code.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>t</code> - Throwable</dd>
<dt>Returns:</dt>
<dd>Stack trace</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="pre(boolean,java.lang.String)">
<h3>pre</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">pre</span><wbr><span class="parameters">(boolean&nbsp;b,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;description)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use <code>Preconditions.checkArgument(boolean)</code>
 or <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Objects.html#requireNonNull(T)" title="class or interface in java.util" class="external-link"><code>Objects.requireNonNull(Object)</code></a></div>
</div>
</section>
</li>
<li>
<section class="detail" id="post(boolean,java.lang.String)">
<h3>post</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">post</span><wbr><span class="parameters">(boolean&nbsp;b,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;description)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use <code>Preconditions.checkArgument(boolean)</code>
 or <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Objects.html#requireNonNull(T)" title="class or interface in java.util" class="external-link"><code>Objects.requireNonNull(Object)</code></a></div>
</div>
</section>
</li>
<li>
<section class="detail" id="permAssert(boolean,java.lang.String)">
<h3>permAssert</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">permAssert</span><wbr><span class="parameters">(boolean&nbsp;b,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;description)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use <code>Preconditions.checkArgument(boolean)</code></div>
</div>
</section>
</li>
<li>
<section class="detail" id="needToImplement(java.lang.Object)">
<h3>needToImplement</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/RuntimeException.html" title="class or interface in java.lang" class="external-link">RuntimeException</a></span>&nbsp;<span class="element-name">needToImplement</span><wbr><span class="parameters">(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&nbsp;o)</span></div>
<div class="block">Returns a <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/RuntimeException.html" title="class or interface in java.lang" class="external-link"><code>RuntimeException</code></a> indicating that a particular
 feature has not been implemented, but should be.

 <p>If every 'hole' in our functionality uses this method, it will be
 easier for us to identity the holes. Throwing a
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/UnsupportedOperationException.html" title="class or interface in java.lang" class="external-link"><code>UnsupportedOperationException</code></a> isn't as good, because
 sometimes we actually want to partially implement an API.

 <p>Example usage:

 <blockquote>
 <pre><code>class MyVisitor extends BaseVisitor {
     void accept(Foo foo) {
         // Exception will identify which subclass forgot to override
         // this method
         throw Util.needToImplement(this);
     }
 }</code></pre>
 </blockquote></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>o</code> - The object which was the target of the call, or null. Passing
          the object gives crucial information if a method needs to be
          overridden and a subclass forgot to do so.</dd>
<dt>Returns:</dt>
<dd>an <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/UnsupportedOperationException.html" title="class or interface in java.lang" class="external-link"><code>UnsupportedOperationException</code></a>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="deprecated(T,boolean)">
<h3 id="deprecated(java.lang.Object,boolean)">deprecated</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;T&gt;</span>&nbsp;<span class="return-type">T</span>&nbsp;<span class="element-name">deprecated</span><wbr><span class="parameters">(T&nbsp;argument,
 boolean&nbsp;fail)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">If a piece of code calls this method, it indicates that the
 code needs to be cleaned up.</div>
</div>
<div class="block">Flags a piece of code as needing to be cleaned up before you check in.

 <p>Introduce a call to this method to indicate that a piece of code, or a
 javadoc comment, needs work before you check in. If you have an IDE which
 can easily trace references, this is an easy way to maintain a to-do
 list.

 <p><strong>Checked-in code must never call this method</strong>: you must
 remove all calls/references to this method before you check in.

 <p>The <code>argument</code> has generic type and determines the type of
 the result. This allows you to use the method inside an expression, for
 example

 <blockquote>
 <pre><code>int x = Util.deprecated(0, false);</code></pre>
 </blockquote>

 <p>but the usual usage is to pass in a descriptive string.

 <p><b>Examples</b>

 <p><b>Example #1: Using <code>deprecated</code> to fail if a piece of
 supposedly dead code is reached</b>

 <blockquote>
 <pre><code>void foo(int x) {
     if (x &lt; 0) {
         // If this code is executed, an error will be thrown.
         Util.deprecated(
             "no longer need to handle negative numbers", true);
         bar(x);
     } else {
         baz(x);
     }
 }</code></pre>
 </blockquote>

 <p><b>Example #2: Using <code>deprecated</code> to comment out dead
 code</b>

 <blockquote>
 <pre>if (Util.deprecated(false, false)) {
     // This code will not be executed, but an error will not be thrown.
     baz();
 }</pre>
 </blockquote></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>argument</code> - Arbitrary argument to the method.</dd>
<dd><code>fail</code> - Whether to throw an exception if this method is called</dd>
<dt>Returns:</dt>
<dd>The value of the <code>argument</code>.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="contains(java.lang.String[],int,java.lang.String)">
<h3>contains</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">contains</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>[]&nbsp;a,
 int&nbsp;length,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</span></div>
<div class="block">Returns whether an array of strings contains a given string among the
 first <code>length</code> entries.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>a</code> - Array of strings</dd>
<dd><code>length</code> - Number of entries to search</dd>
<dd><code>s</code> - String to seek</dd>
<dt>Returns:</dt>
<dd>Whether array contains the name</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="readAllAsString(java.io.Reader)">
<h3>readAllAsString</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">readAllAsString</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/io/Reader.html" title="class or interface in java.io" class="external-link">Reader</a>&nbsp;reader)</span>
                              throws <span class="exceptions"><a href="https://docs.oracle.com/javase/9/docs/api/java/io/IOException.html" title="class or interface in java.io" class="external-link">IOException</a></span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
<div class="block">Reads all remaining contents from a <a href="https://docs.oracle.com/javase/9/docs/api/java/io/Reader.html" title="class or interface in java.io" class="external-link"><code>Reader</code></a> and returns
 them as a string.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>reader</code> - reader to read from</dd>
<dt>Returns:</dt>
<dd>reader contents as string</dd>
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/javase/9/docs/api/java/io/IOException.html" title="class or interface in java.io" class="external-link">IOException</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="squelchJar(java.util.jar.JarFile)">
<h3>squelchJar</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">squelchJar</span><wbr><span class="parameters">(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/util/jar/JarFile.html" title="class or interface in java.util.jar" class="external-link">JarFile</a>&nbsp;jar)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
<div class="block">Closes a Jar, ignoring any I/O exception. This should only be
 used in finally blocks when it's necessary to avoid throwing an exception
 which might mask a real exception.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>jar</code> - jar to close</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="squelchStream(java.io.InputStream)">
<h3>squelchStream</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">squelchStream</span><wbr><span class="parameters">(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;stream)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
<div class="block">Closes an InputStream, ignoring any I/O exception. This should only be
 used in finally blocks when it's necessary to avoid throwing an exception
 which might mask a real exception.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>stream</code> - stream to close</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="squelchStream(java.io.OutputStream)">
<h3>squelchStream</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">squelchStream</span><wbr><span class="parameters">(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/io/OutputStream.html" title="class or interface in java.io" class="external-link">OutputStream</a>&nbsp;stream)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
<div class="block">Closes an OutputStream, ignoring any I/O exception. This should only be
 used in finally blocks when it's necessary to avoid throwing an exception
 which might mask a real exception. If you want to make sure that data has
 been successfully flushed, do NOT use this anywhere else; use
 stream.close() instead.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>stream</code> - stream to close</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="squelchReader(java.io.Reader)">
<h3>squelchReader</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">squelchReader</span><wbr><span class="parameters">(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/io/Reader.html" title="class or interface in java.io" class="external-link">Reader</a>&nbsp;reader)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
<div class="block">Closes a Reader, ignoring any I/O exception. This should only be used in
 finally blocks when it's necessary to avoid throwing an exception which
 might mask a real exception.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>reader</code> - reader to close</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="squelchWriter(java.io.Writer)">
<h3>squelchWriter</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">squelchWriter</span><wbr><span class="parameters">(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/io/Writer.html" title="class or interface in java.io" class="external-link">Writer</a>&nbsp;writer)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
<div class="block">Closes a Writer, ignoring any I/O exception. This should only be used in
 finally blocks when it's necessary to avoid throwing an exception which
 might mask a real exception. If you want to make sure that data has been
 successfully flushed, do NOT use this anywhere else; use writer.close()
 instead.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>writer</code> - writer to close</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="squelchStmt(java.sql.Statement)">
<h3>squelchStmt</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">squelchStmt</span><wbr><span class="parameters">(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/sql/Statement.html" title="class or interface in java.sql" class="external-link">Statement</a>&nbsp;stmt)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
<div class="block">Closes a Statement, ignoring any SQL exception. This should only be used
 in finally blocks when it's necessary to avoid throwing an exception
 which might mask a real exception.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>stmt</code> - stmt to close</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="squelchConnection(java.sql.Connection)">
<h3>squelchConnection</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">squelchConnection</span><wbr><span class="parameters">(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/sql/Connection.html" title="class or interface in java.sql" class="external-link">Connection</a>&nbsp;connection)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
<div class="block">Closes a Connection, ignoring any SQL exception. This should only be used
 in finally blocks when it's necessary to avoid throwing an exception
 which might mask a real exception.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>connection</code> - connection to close</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="rtrim(java.lang.String)">
<h3>rtrim</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">rtrim</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
<div class="block">Trims trailing spaces from a string.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>s</code> - string to be trimmed</dd>
<dt>Returns:</dt>
<dd>trimmed string</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="rpad(java.lang.String,int)">
<h3>rpad</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">rpad</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 int&nbsp;len)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span>
<div class="deprecation-comment">Use <code>Spaces.padRight(String, int)</code></div>
</div>
<div class="block">Pads a string with spaces up to a given length.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>s</code> - string to be padded</dd>
<dd><code>len</code> - desired length</dd>
<dt>Returns:</dt>
<dd>padded string</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="toString(java.lang.Iterable,java.lang.String,java.lang.String,java.lang.String)">
<h3>toString</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;T&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">toString</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;T&gt;&nbsp;iterable,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;start,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;sep,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;end)</span></div>
<div class="block">Converts an iterable to a string.</div>
</section>
</li>
<li>
<section class="detail" id="lines(java.lang.Iterable)">
<h3>lines</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">lines</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;strings)</span></div>
<div class="block">Converts a list of strings to a string separated by newlines.</div>
</section>
</li>
<li>
<section class="detail" id="tokenize(java.lang.String,java.lang.String)">
<h3>tokenize</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</span>&nbsp;<span class="element-name">tokenize</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;delim)</span></div>
<div class="block">Converts a string into tokens.</div>
</section>
</li>
<li>
<section class="detail" id="toPosix(java.util.TimeZone,boolean)">
<h3>toPosix</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">toPosix</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/TimeZone.html" title="class or interface in java.util" class="external-link">TimeZone</a>&nbsp;tz,
 boolean&nbsp;verbose)</span></div>
<div class="block">Converts a Java timezone to POSIX format, so that the boost C++ library
 can instantiate timezone objects.

 <p><a href="http://www.opengroup.org/onlinepubs/000095399/basedefs/xbd_chap08.html">POSIX
 IEEE 1003.1</a> defines a format for timezone specifications.

 <p>The boost C++ library can read these specifications and instantiate <a href="http://www.boost.org/doc/html/date_time/local_time.html#date_time.local_time.posix_time_zone">
 posix_time_zone</a> objects from them. The purpose of this method,
 therefore, is to allow the C++ code such as the fennel calculator to use
 the same notion of timezone as Java code.

 <p>The format is as follows:

 <blockquote>"std offset dst [offset],start[/time],end[/time]"
 </blockquote>

 <p>where:

 <ul>
 <li>'std' specifies the abbrev of the time zone.
 <li>'offset' is the offset from UTC, and takes the form
     <code>[+|-]hh[:mm[:ss]] {h=0-23, m/s=0-59}</code></li>
 <li>'dst' specifies the abbrev of the time zone during daylight savings
 time
 <li>The second offset is how many hours changed during DST. Default=1
 <li>'start' and 'end' are the dates when DST goes into (and out of)
     effect.<br>
     <br>
     They can each be one of three forms:

     <ol>
     <li>Mm.w.d {month=1-12, week=1-5 (5 is always last), day=0-6}
     <li>Jn {n=1-365 Feb29 is never counted}
     <li>n {n=0-365 Feb29 is counted in leap years}
     </ol>
 </li>

 <li>'time' has the same format as 'offset', and defaults to 02:00:00.</li>
 </ul>

 <p>For example:</p>

 <ul>
 <li>"PST-8PDT01:00:00,M4.1.0/02:00:00,M10.1.0/02:00:00"; or more tersely
 <li>"PST-8PDT,M4.1.0,M10.1.0"
 </ul>

 <p>(Real format strings do not contain spaces; they are in the above
 template only for readability.)

 <p>Boost apparently diverges from the POSIX standard in how it treats the
 sign of timezone offsets. The POSIX standard states '<i>If preceded by a
 '-', the timezone shall be east of the Prime Meridian; otherwise, it
 shall be west</i>', yet boost requires the opposite. For instance, PST
 has offset '-8' above. This method generates timezone strings consistent
 with boost's expectations.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>tz</code> - Timezone</dd>
<dd><code>verbose</code> - Whether to include fields which can be omitted because
                they have their default values</dd>
<dt>Returns:</dt>
<dd>Timezone in POSIX format (offset sign reversed, per boost's
 idiosyncracies)</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="parseLocale(java.lang.String)">
<h3>parseLocale</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/Locale.html" title="class or interface in java.util" class="external-link">Locale</a></span>&nbsp;<span class="element-name">parseLocale</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;localeString)</span></div>
<div class="block">Parses a locale string.

 <p>The inverse operation of <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Locale.html#toString()" title="class or interface in java.util" class="external-link"><code>Locale.toString()</code></a>.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>localeString</code> - Locale string, e.g. "en" or "en_US"</dd>
<dt>Returns:</dt>
<dd>Java locale object</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="cast(java.util.List,java.lang.Class)">
<h3>cast</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;</span>&nbsp;<span class="element-name">cast</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? super E&gt;&nbsp;list,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;E&gt;&nbsp;clazz)</span></div>
<div class="block">Converts a list whose members are automatically down-cast to a given
 type.

 <p>If a member of the backing list is not an instanceof <code>E</code>,
 the accessing method (such as <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html#get(int)" title="class or interface in java.util" class="external-link"><code>List.get(int)</code></a>) will throw a
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/ClassCastException.html" title="class or interface in java.lang" class="external-link"><code>ClassCastException</code></a>.

 <p>All modifications are automatically written to the backing list. Not
 synchronized.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>list</code> - Backing list.</dd>
<dd><code>clazz</code> - Class to cast to.</dd>
<dt>Returns:</dt>
<dd>A list whose members are of the desired type.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="cast(java.util.Iterator,java.lang.Class)">
<h3>cast</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E extends @PolyNull <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;</span>
<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/Iterator.html" title="class or interface in java.util" class="external-link">Iterator</a>&lt;E&gt;</span>&nbsp;<span class="element-name">cast</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/Iterator.html" title="class or interface in java.util" class="external-link">Iterator</a>&lt;? extends @PolyNull <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>&gt;&nbsp;iter,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;E&gt;&nbsp;clazz)</span></div>
<div class="block">Converts a iterator whose members are automatically down-cast to a given
 type.

 <p>If a member of the backing iterator is not an instance of <code>E</code>,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Iterator.html#next()" title="class or interface in java.util" class="external-link"><code>Iterator.next()</code></a>) will throw a
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/ClassCastException.html" title="class or interface in java.lang" class="external-link"><code>ClassCastException</code></a>.

 <p>All modifications are automatically written to the backing iterator.
 Not synchronized.

 <p>If the backing iterator has not-nullable elements,
 the returned iterator has not-nullable elements.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>iter</code> - Backing iterator</dd>
<dd><code>clazz</code> - Class to cast to</dd>
<dt>Returns:</dt>
<dd>An iterator whose members are of the desired type.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="cast(java.lang.Iterable,java.lang.Class)">
<h3>cast</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;E&gt;</span>&nbsp;<span class="element-name">cast</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;? super E&gt;&nbsp;iterable,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;E&gt;&nbsp;clazz)</span></div>
<div class="block">Converts an <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link"><code>Iterable</code></a> whose members are automatically down-cast to
 a given type.

 <p>All modifications are automatically written to the backing iterator.
 Not synchronized.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>iterable</code> - Backing iterable</dd>
<dd><code>clazz</code> - Class to cast to</dd>
<dt>Returns:</dt>
<dd>An iterable whose members are of the desired type.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="filter(java.lang.Iterable,java.lang.Class)">
<h3>filter</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;E&gt;</span>&nbsp;<span class="element-name">filter</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;?&gt;&nbsp;iterable,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;E&gt;&nbsp;includeFilter)</span></div>
<div class="block">Makes a collection of untyped elements appear as a list of strictly typed
 elements, by filtering out those which are not of the correct type.

 <p>The returned object is an <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link"><code>Iterable</code></a>,
 which makes it ideal for use with the 'foreach' construct. For example,

 <blockquote><code>List&lt;Number&gt; numbers = Arrays.asList(1, 2, 3.14,
 4, null, 6E23);<br>
 for (int myInt : filter(numbers, Integer.class)) {<br>
 &nbsp;&nbsp;&nbsp;&nbsp;print(i);<br>
 }</code></blockquote>

 <p>will print 1, 2, 4.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>iterable</code> - Iterable</dd>
<dd><code>includeFilter</code> - Class whose instances to include</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="filter(java.util.Collection,java.lang.Class)">
<h3>filter</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;E&gt;</span>&nbsp;<span class="element-name">filter</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;?&gt;&nbsp;collection,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;E&gt;&nbsp;includeFilter)</span></div>
</section>
</li>
<li>
<section class="detail" id="filter(java.util.List,java.lang.Class)">
<h3>filter</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;</span>&nbsp;<span class="element-name">filter</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;?&gt;&nbsp;list,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;E&gt;&nbsp;includeFilter)</span></div>
<div class="block">Returns a subset of a list containing only elements of a given type.

 <p>Modifications to the list are NOT written back to the source list.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>list</code> - List of objects</dd>
<dd><code>includeFilter</code> - Class to filter for</dd>
<dt>Returns:</dt>
<dd>List of objects of given class (or a subtype)</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="toMap(java.util.Properties)">
<h3>toMap</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</span>&nbsp;<span class="element-name">toMap</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/Properties.html" title="class or interface in java.util" class="external-link">Properties</a>&nbsp;properties)</span></div>
<div class="block">Converts a <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Properties.html" title="class or interface in java.util" class="external-link"><code>Properties</code></a> object to a <code><a href="https://docs.oracle.com/javase/9/docs/api/java/util/Map.html" title="class or interface in java.util" class="external-link"><code>Map</code></a>&lt;String,
 String&gt;</code>.

 <p>This is necessary because <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Properties.html" title="class or interface in java.util" class="external-link"><code>Properties</code></a> is a dinosaur class. It
 ought to extend <code>Map&lt;String,String&gt;</code>, but instead
 extends <code><a href="https://docs.oracle.com/javase/9/docs/api/java/util/Hashtable.html" title="class or interface in java.util" class="external-link"><code>Hashtable</code></a>&lt;Object,Object&gt;</code>.

 <p>Typical usage, to iterate over a <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Properties.html" title="class or interface in java.util" class="external-link"><code>Properties</code></a>:

 <blockquote>
 <code>
 Properties properties;<br>
 for (Map.Entry&lt;String, String&gt; entry =
 Util.toMap(properties).entrySet()) {<br>
 println("key=" + entry.getKey() + ", value=" + entry.getValue());<br>
 }
 </code>
 </blockquote></div>
</section>
</li>
<li>
<section class="detail" id="mapOf(K,V,java.lang.Object...)">
<h3 id="mapOf(java.lang.Object,java.lang.Object,java.lang.Object[])">mapOf</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;K,<wbr>
V&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;K,<wbr>V&gt;</span>&nbsp;<span class="element-name">mapOf</span><wbr><span class="parameters">(K&nbsp;key,
 V&nbsp;value,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>...&nbsp;keyValues)</span></div>
<div class="block">Returns a hashmap with given contents.

 <p>Use this method in initializers. Type parameters are inferred from
 context, and the contents are initialized declaratively. For example,

 <blockquote><code>Map&lt;String, Integer&gt; population =<br>
 &nbsp;&nbsp;Olap4jUtil.mapOf(<br>
 &nbsp;&nbsp;&nbsp;&nbsp;"UK", 65000000,<br>
 &nbsp;&nbsp;&nbsp;&nbsp;"USA", 300000000);</code></blockquote></div>
<dl class="notes">
<dt>Type Parameters:</dt>
<dd><code>K</code> - Key type</dd>
<dd><code>V</code> - Value type</dd>
<dt>Parameters:</dt>
<dd><code>key</code> - First key</dd>
<dd><code>value</code> - First value</dd>
<dd><code>keyValues</code> - Second and sequent key/value pairs</dd>
<dt>Returns:</dt>
<dd>Map with given contents</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="unexpected(E)">
<h3 id="unexpected(java.lang.Enum)">unexpected</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E extends <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Enum.html" title="class or interface in java.lang" class="external-link">Enum</a>&lt;E&gt;&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Error.html" title="class or interface in java.lang" class="external-link">Error</a></span>&nbsp;<span class="element-name">unexpected</span><wbr><span class="parameters">(E&nbsp;value)</span></div>
<div class="block">Returns an exception indicating that we didn't expect to find this
 enumeration here.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>value</code> - Enumeration value which was not expected</dd>
<dt>Returns:</dt>
<dd>an error, to be thrown</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="enumConstants(java.lang.Class)">
<h3>enumConstants</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;T extends <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Enum.html" title="class or interface in java.lang" class="external-link">Enum</a>&lt;T&gt;&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>,<wbr>T&gt;</span>&nbsp;<span class="element-name">enumConstants</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;T&gt;&nbsp;clazz)</span></div>
<div class="block">Creates a map of the values of an enumeration by name.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>clazz</code> - Enumeration class</dd>
<dt>Returns:</dt>
<dd>map of values</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="enumVal(java.lang.Class,java.lang.String)">
<h3>enumVal</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;T extends <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Enum.html" title="class or interface in java.lang" class="external-link">Enum</a>&lt;T&gt;&gt;</span>&nbsp;<span class="return-type">@Nullable T</span>&nbsp;<span class="element-name">enumVal</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;T&gt;&nbsp;clazz,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name)</span></div>
<div class="block">Returns the value of an enumeration with a particular name.

 <p>Similar to <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Enum.html#valueOf(java.lang.Class,java.lang.String)" title="class or interface in java.lang" class="external-link"><code>Enum.valueOf(Class, String)</code></a>, but returns <code>
 null</code> rather than throwing <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/IllegalArgumentException.html" title="class or interface in java.lang" class="external-link"><code>IllegalArgumentException</code></a>.</div>
<dl class="notes">
<dt>Type Parameters:</dt>
<dd><code>T</code> - Enum class type</dd>
<dt>Parameters:</dt>
<dd><code>clazz</code> - Enum class</dd>
<dd><code>name</code> - Name of enum constant</dd>
<dt>Returns:</dt>
<dd>Enum constant or null</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="enumVal(T,java.lang.String)">
<h3 id="enumVal(java.lang.Enum,java.lang.String)">enumVal</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;T extends <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Enum.html" title="class or interface in java.lang" class="external-link">Enum</a>&lt;T&gt;&gt;</span>&nbsp;<span class="return-type">T</span>&nbsp;<span class="element-name">enumVal</span><wbr><span class="parameters">(T&nbsp;default_,
 @Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;name)</span></div>
<div class="block">Returns the value of an enumeration with a particular or default value if
 not found.</div>
<dl class="notes">
<dt>Type Parameters:</dt>
<dd><code>T</code> - Enum class type</dd>
<dt>Parameters:</dt>
<dd><code>default_</code> - Default value (not null)</dd>
<dd><code>name</code> - Name of enum constant</dd>
<dt>Returns:</dt>
<dd>Enum constant, never null</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="quotientList(java.util.List,int,int)">
<h3>quotientList</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;</span>&nbsp;<span class="element-name">quotientList</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list,
 int&nbsp;n,
 int&nbsp;k)</span></div>
<div class="block">Creates a list that returns every <code>n</code>th element of a list,
 starting at element <code>k</code>.

 <p>It is OK if the list is empty or its size is not a multiple of
 <code>n</code>.</p>

 <p>For instance, <code>quotientList(list, 2, 0)</code> returns the even
 elements of a list, and <code>quotientList(list, 2, 1)</code> returns the odd
 elements. Those lists are the same length only if list has even size.</p></div>
</section>
</li>
<li>
<section class="detail" id="pairs(java.util.List)">
<h3>pairs</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="Pair.html" title="class in org.apache.calcite.util">Pair</a>&lt;E,<wbr>E&gt;&gt;</span>&nbsp;<span class="element-name">pairs</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list)</span></div>
<div class="block">Given a list with N elements
 [e<sub>0</sub>, e<sub>1</sub>, ..., e<sub>N-1</sub>]
 (where N is even), returns a list of the N / 2 elements
 [ (e<sub>0</sub>, e<sub>1</sub>),
 (e<sub>2</sub>, e<sub>3</sub>), ... ].</div>
</section>
</li>
<li>
<section class="detail" id="first(T,T)">
<h3 id="first(java.lang.Object,java.lang.Object)">first</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;T&gt;</span>&nbsp;<span class="return-type">@PolyNull T</span>&nbsp;<span class="element-name">first</span><wbr><span class="parameters">(@Nullable T&nbsp;v0,
 @PolyNull T&nbsp;v1)</span></div>
<div class="block">Returns the first value if it is not null,
 otherwise the second value.

 <p>The result may be null only if the second argument is not null.

 <p>Equivalent to the Elvis operator (<code>?:</code>) of languages such as
 Groovy or PHP.</div>
</section>
</li>
<li>
<section class="detail" id="first(java.lang.Double,double)">
<h3>first</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">double</span>&nbsp;<span class="element-name">first</span><wbr><span class="parameters">(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Double.html" title="class or interface in java.lang" class="external-link">Double</a>&nbsp;v0,
 double&nbsp;v1)</span></div>
<div class="block">Unboxes a <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Double.html" title="class or interface in java.lang" class="external-link"><code>Double</code></a> value,
 using a given default value if it is null.</div>
</section>
</li>
<li>
<section class="detail" id="first(java.lang.Float,float)">
<h3>first</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">float</span>&nbsp;<span class="element-name">first</span><wbr><span class="parameters">(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Float.html" title="class or interface in java.lang" class="external-link">Float</a>&nbsp;v0,
 float&nbsp;v1)</span></div>
<div class="block">Unboxes a <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Float.html" title="class or interface in java.lang" class="external-link"><code>Float</code></a> value,
 using a given default value if it is null.</div>
</section>
</li>
<li>
<section class="detail" id="first(java.lang.Integer,int)">
<h3>first</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">first</span><wbr><span class="parameters">(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&nbsp;v0,
 int&nbsp;v1)</span></div>
<div class="block">Unboxes a <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Integer.html" title="class or interface in java.lang" class="external-link"><code>Integer</code></a> value,
 using a given default value if it is null.</div>
</section>
</li>
<li>
<section class="detail" id="first(java.lang.Long,long)">
<h3>first</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">long</span>&nbsp;<span class="element-name">first</span><wbr><span class="parameters">(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Long.html" title="class or interface in java.lang" class="external-link">Long</a>&nbsp;v0,
 long&nbsp;v1)</span></div>
<div class="block">Unboxes a <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Long.html" title="class or interface in java.lang" class="external-link"><code>Long</code></a> value,
 using a given default value if it is null.</div>
</section>
</li>
<li>
<section class="detail" id="first(java.lang.Boolean,boolean)">
<h3>first</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">first</span><wbr><span class="parameters">(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link">Boolean</a>&nbsp;v0,
 boolean&nbsp;v1)</span></div>
<div class="block">Unboxes a <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Boolean.html" title="class or interface in java.lang" class="external-link"><code>Boolean</code></a> value,
 using a given default value if it is null.</div>
</section>
</li>
<li>
<section class="detail" id="first(java.lang.Short,short)">
<h3>first</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">short</span>&nbsp;<span class="element-name">first</span><wbr><span class="parameters">(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Short.html" title="class or interface in java.lang" class="external-link">Short</a>&nbsp;v0,
 short&nbsp;v1)</span></div>
<div class="block">Unboxes a <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Short.html" title="class or interface in java.lang" class="external-link"><code>Short</code></a> value,
 using a given default value if it is null.</div>
</section>
</li>
<li>
<section class="detail" id="first(java.lang.Character,char)">
<h3>first</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">char</span>&nbsp;<span class="element-name">first</span><wbr><span class="parameters">(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Character.html" title="class or interface in java.lang" class="external-link">Character</a>&nbsp;v0,
 char&nbsp;v1)</span></div>
<div class="block">Unboxes a <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Character.html" title="class or interface in java.lang" class="external-link"><code>Character</code></a> value,
 using a given default value if it is null.</div>
</section>
</li>
<li>
<section class="detail" id="first(java.lang.Byte,byte)">
<h3>first</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">byte</span>&nbsp;<span class="element-name">first</span><wbr><span class="parameters">(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Byte.html" title="class or interface in java.lang" class="external-link">Byte</a>&nbsp;v0,
 byte&nbsp;v1)</span></div>
<div class="block">Unboxes a <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Byte.html" title="class or interface in java.lang" class="external-link"><code>Byte</code></a> value,
 using a given default value if it is null.</div>
</section>
</li>
<li>
<section class="detail" id="orEmpty(java.lang.Iterable)">
<h3>orEmpty</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;T&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;T&gt;</span>&nbsp;<span class="element-name">orEmpty</span><wbr><span class="parameters">(@Nullable <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;T&gt;&nbsp;v0)</span></div>
</section>
</li>
<li>
<section class="detail" id="first(java.util.List)">
<h3>first</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type">E</span>&nbsp;<span class="element-name">first</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list)</span></div>
<div class="block">Returns the first element of a list.</div>
<dl class="notes">
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/IndexOutOfBoundsException.html" title="class or interface in java.lang" class="external-link">IndexOutOfBoundsException</a></code> - if the list is empty</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="last(java.util.List)">
<h3>last</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type">E</span>&nbsp;<span class="element-name">last</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list)</span></div>
<div class="block">Returns the last element of a list.</div>
<dl class="notes">
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/IndexOutOfBoundsException.html" title="class or interface in java.lang" class="external-link">IndexOutOfBoundsException</a></code> - if the list is empty</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="first(java.util.List,int)">
<h3>first</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;</span>&nbsp;<span class="element-name">first</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list,
 int&nbsp;n)</span></div>
<div class="block">Returns the first <code>n</code> elements of a list.</div>
</section>
</li>
<li>
<section class="detail" id="skipLast(java.util.List)">
<h3>skipLast</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;</span>&nbsp;<span class="element-name">skipLast</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list)</span></div>
<div class="block">Returns every element of a list but its last element.</div>
</section>
</li>
<li>
<section class="detail" id="skipLast(java.util.List,int)">
<h3>skipLast</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;</span>&nbsp;<span class="element-name">skipLast</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list,
 int&nbsp;n)</span></div>
<div class="block">Returns every element of a list but its last <code>n</code> elements.</div>
</section>
</li>
<li>
<section class="detail" id="last(java.util.List,int)">
<h3>last</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;</span>&nbsp;<span class="element-name">last</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list,
 int&nbsp;n)</span></div>
<div class="block">Returns the last <code>n</code> elements of a list.</div>
</section>
</li>
<li>
<section class="detail" id="skip(java.util.List)">
<h3>skip</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;</span>&nbsp;<span class="element-name">skip</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list)</span></div>
<div class="block">Returns all but the first element of a list.</div>
</section>
</li>
<li>
<section class="detail" id="skip(java.util.List,int)">
<h3>skip</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;</span>&nbsp;<span class="element-name">skip</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list,
 int&nbsp;fromIndex)</span></div>
<div class="block">Returns all but the first <code>n</code> elements of a list.</div>
</section>
</li>
<li>
<section class="detail" id="range(int)">
<h3>range</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;</span>&nbsp;<span class="element-name">range</span><wbr><span class="parameters">(int&nbsp;end)</span></div>
</section>
</li>
<li>
<section class="detail" id="range(int,int)">
<h3>range</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;</span>&nbsp;<span class="element-name">range</span><wbr><span class="parameters">(int&nbsp;start,
 int&nbsp;end)</span></div>
</section>
</li>
<li>
<section class="detail" id="isDistinct(java.util.List)">
<h3>isDistinct</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isDistinct</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list)</span></div>
<div class="block">Returns whether the elements of <code>list</code> are distinct.</div>
</section>
</li>
<li>
<section class="detail" id="firstDuplicate(java.util.List)">
<h3>firstDuplicate</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">firstDuplicate</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list)</span></div>
<div class="block">Returns the ordinal of the first element in the list which is equal to a
 previous element in the list.

 <p>For example,
 <code>firstDuplicate(Arrays.asList("a", "b", "c", "b", "a"))</code>
 returns 3, the ordinal of the 2nd "b".</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>list</code> - List</dd>
<dt>Returns:</dt>
<dd>Ordinal of first duplicate, or -1 if not found</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="distinctList(java.util.List)">
<h3>distinctList</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;</span>&nbsp;<span class="element-name">distinctList</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list)</span></div>
<div class="block">Converts a list into a list with unique elements.

 <p>The order is preserved; the second and subsequent occurrences are
 removed.

 <p>If the list is already unique it is returned unchanged.</div>
</section>
</li>
<li>
<section class="detail" id="distinctList(java.lang.Iterable)">
<h3>distinctList</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;</span>&nbsp;<span class="element-name">distinctList</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;E&gt;&nbsp;keys)</span></div>
<div class="block">Converts an iterable into a list with unique elements.

 <p>The order is preserved; the second and subsequent occurrences are
 removed.

 <p>If <code>iterable</code> is a unique list it is returned unchanged.</div>
</section>
</li>
<li>
<section class="detail" id="intersects(java.util.Collection,java.util.Collection)">
<h3>intersects</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">intersects</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;E&gt;&nbsp;c0,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;E&gt;&nbsp;c1)</span></div>
<div class="block">Returns whether two collections have any elements in common.</div>
</section>
</li>
<li>
<section class="detail" id="findMatch(java.util.List,java.lang.String,boolean)">
<h3>findMatch</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">int</span>&nbsp;<span class="element-name">findMatch</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;strings,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;seek,
 boolean&nbsp;caseSensitive)</span></div>
<div class="block">Looks for a string within a list of strings, using a given
 case-sensitivity policy, and returns the position at which the first match
 is found, or -1 if there are no matches.</div>
</section>
</li>
<li>
<section class="detail" id="matches(boolean,java.lang.String,java.lang.String)">
<h3>matches</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">matches</span><wbr><span class="parameters">(boolean&nbsp;caseSensitive,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s0,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s1)</span></div>
<div class="block">Returns whether a name matches another according to a given
 case-sensitivity policy.</div>
</section>
</li>
<li>
<section class="detail" id="startsWith(java.util.List,java.util.List)">
<h3>startsWith</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">startsWith</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list0,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list1)</span></div>
<div class="block">Returns whether one list is a prefix of another.</div>
</section>
</li>
<li>
<section class="detail" id="listToString(java.util.List)">
<h3>listToString</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">listToString</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;&nbsp;list)</span></div>
<div class="block">Converts ["ab", "c"] to "ab"."c".</div>
</section>
</li>
<li>
<section class="detail" id="stringToList(java.lang.String)">
<h3>stringToList</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&gt;</span>&nbsp;<span class="element-name">stringToList</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;s)</span></div>
</section>
</li>
<li>
<section class="detail" id="human(double)">
<h3>human</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">human</span><wbr><span class="parameters">(double&nbsp;d)</span></div>
<div class="block">Converts a number into human-readable form, with 3 digits and a "K", "M"
 or "G" multiplier for thousands, millions or billions.

 <p>Examples: -2, 0, 1, 999, 1.00K, 1.99K, 3.45M, 4.56B.</p></div>
</section>
</li>
<li>
<section class="detail" id="asIndexMapJ(java.util.Collection,java.util.function.Function)">
<h3>asIndexMapJ</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;K,<wbr>
V&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;K,<wbr>V&gt;</span>&nbsp;<span class="element-name">asIndexMapJ</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;V&gt;&nbsp;values,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/Function.html" title="class or interface in java.util.function" class="external-link">Function</a>&lt;V,<wbr>K&gt;&nbsp;function)</span></div>
<div class="block">Returns a map that is a view onto a collection of values, using the
 provided function to convert a value to a key.

 <p>Unlike
 <code>Maps.uniqueIndex(Iterable, com.google.common.base.Function)</code>,
 returns a view whose contents change as the collection of values changes.</div>
<dl class="notes">
<dt>Type Parameters:</dt>
<dd><code>K</code> - Key type</dd>
<dd><code>V</code> - Value type</dd>
<dt>Parameters:</dt>
<dd><code>values</code> - Collection of values</dd>
<dd><code>function</code> - Function to map value to key</dd>
<dt>Returns:</dt>
<dd>Map that is a view onto the values</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="asIndexMap(java.util.Collection,com.google.common.base.Function)">
<h3>asIndexMap</h3>
<div class="member-signature"><span class="annotations"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Deprecated.html" title="class or interface in java.lang" class="external-link">@Deprecated</a>
</span><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;K,<wbr>
V&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;K,<wbr>V&gt;</span>&nbsp;<span class="element-name">asIndexMap</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/Collection.html" title="class or interface in java.util" class="external-link">Collection</a>&lt;V&gt;&nbsp;values,
 com.google.common.base.Function&lt;V,<wbr>K&gt;&nbsp;function)</span></div>
<div class="deprecation-block"><span class="deprecated-label">Deprecated.</span></div>
</section>
</li>
<li>
<section class="detail" id="debugCode(java.io.PrintStream,java.lang.String)">
<h3>debugCode</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">debugCode</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/io/PrintStream.html" title="class or interface in java.io" class="external-link">PrintStream</a>&nbsp;out,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;code)</span></div>
<div class="block">Prints the given code with line numbering.</div>
</section>
</li>
<li>
<section class="detail" id="immutableCopy(java.lang.Iterable)">
<h3>immutableCopy</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&gt;</span>&nbsp;<span class="element-name">immutableCopy</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;? extends <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;E&gt;&gt;&nbsp;lists)</span></div>
<div class="block">Returns a copy of a list of lists, making the component lists immutable if
 they are not already.</div>
</section>
</li>
<li>
<section class="detail" id="printWriter(java.io.OutputStream)">
<h3>printWriter</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/io/PrintWriter.html" title="class or interface in java.io" class="external-link">PrintWriter</a></span>&nbsp;<span class="element-name">printWriter</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/io/OutputStream.html" title="class or interface in java.io" class="external-link">OutputStream</a>&nbsp;out)</span></div>
<div class="block">Creates a <a href="https://docs.oracle.com/javase/9/docs/api/java/io/PrintWriter.html" title="class or interface in java.io" class="external-link"><code>PrintWriter</code></a> to a given output stream using UTF-8
 character set.

 <p>Does not use the default character set.</div>
</section>
</li>
<li>
<section class="detail" id="printWriter(java.io.File)">
<h3>printWriter</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/io/PrintWriter.html" title="class or interface in java.io" class="external-link">PrintWriter</a></span>&nbsp;<span class="element-name">printWriter</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/io/File.html" title="class or interface in java.io" class="external-link">File</a>&nbsp;file)</span>
                               throws <span class="exceptions"><a href="https://docs.oracle.com/javase/9/docs/api/java/io/FileNotFoundException.html" title="class or interface in java.io" class="external-link">FileNotFoundException</a></span></div>
<div class="block">Creates a <a href="https://docs.oracle.com/javase/9/docs/api/java/io/PrintWriter.html" title="class or interface in java.io" class="external-link"><code>PrintWriter</code></a> to a given file using UTF-8
 character set.

 <p>Does not use the default character set.</div>
<dl class="notes">
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/javase/9/docs/api/java/io/FileNotFoundException.html" title="class or interface in java.io" class="external-link">FileNotFoundException</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="reader(java.io.InputStream)">
<h3>reader</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/io/BufferedReader.html" title="class or interface in java.io" class="external-link">BufferedReader</a></span>&nbsp;<span class="element-name">reader</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/io/InputStream.html" title="class or interface in java.io" class="external-link">InputStream</a>&nbsp;in)</span></div>
<div class="block">Creates a <a href="https://docs.oracle.com/javase/9/docs/api/java/io/BufferedReader.html" title="class or interface in java.io" class="external-link"><code>BufferedReader</code></a> to a given input stream using UTF-8
 character set.

 <p>Does not use the default character set.</div>
</section>
</li>
<li>
<section class="detail" id="reader(java.io.File)">
<h3>reader</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/io/BufferedReader.html" title="class or interface in java.io" class="external-link">BufferedReader</a></span>&nbsp;<span class="element-name">reader</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/io/File.html" title="class or interface in java.io" class="external-link">File</a>&nbsp;file)</span>
                             throws <span class="exceptions"><a href="https://docs.oracle.com/javase/9/docs/api/java/io/FileNotFoundException.html" title="class or interface in java.io" class="external-link">FileNotFoundException</a></span></div>
<div class="block">Creates a <a href="https://docs.oracle.com/javase/9/docs/api/java/io/BufferedReader.html" title="class or interface in java.io" class="external-link"><code>BufferedReader</code></a> to read a given file using UTF-8
 character set.

 <p>Does not use the default character set.</div>
<dl class="notes">
<dt>Throws:</dt>
<dd><code><a href="https://docs.oracle.com/javase/9/docs/api/java/io/FileNotFoundException.html" title="class or interface in java.io" class="external-link">FileNotFoundException</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="asStringBuilder(java.lang.Appendable,java.util.function.Consumer)">
<h3>asStringBuilder</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">asStringBuilder</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Appendable.html" title="class or interface in java.lang" class="external-link">Appendable</a>&nbsp;appendable,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/Consumer.html" title="class or interface in java.util.function" class="external-link">Consumer</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/StringBuilder.html" title="class or interface in java.lang" class="external-link">StringBuilder</a>&gt;&nbsp;consumer)</span></div>
<div class="block">Given an <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Appendable.html" title="class or interface in java.lang" class="external-link"><code>Appendable</code></a>, performs an action that requires a
 <a href="https://docs.oracle.com/javase/9/docs/api/java/lang/StringBuilder.html" title="class or interface in java.lang" class="external-link"><code>StringBuilder</code></a>. Casts the Appendable if possible.</div>
</section>
</li>
<li>
<section class="detail" id="calendar()">
<h3>calendar</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/Calendar.html" title="class or interface in java.util" class="external-link">Calendar</a></span>&nbsp;<span class="element-name">calendar</span>()</div>
<div class="block">Creates a <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Calendar.html" title="class or interface in java.util" class="external-link"><code>Calendar</code></a> in the UTC time zone and root locale.
 Does not use the time zone or locale.</div>
</section>
</li>
<li>
<section class="detail" id="calendar(long)">
<h3>calendar</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/Calendar.html" title="class or interface in java.util" class="external-link">Calendar</a></span>&nbsp;<span class="element-name">calendar</span><wbr><span class="parameters">(long&nbsp;millis)</span></div>
<div class="block">Creates a <a href="https://docs.oracle.com/javase/9/docs/api/java/util/Calendar.html" title="class or interface in java.util" class="external-link"><code>Calendar</code></a> in the UTC time zone and root locale
 with a given time.</div>
</section>
</li>
<li>
<section class="detail" id="toImmutableList()">
<h3>toImmutableList</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;T&gt;</span>
<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/stream/Collector.html" title="class or interface in java.util.stream" class="external-link">Collector</a>&lt;T,<wbr>com.google.common.collect.ImmutableList.Builder&lt;T&gt;,<wbr>com.google.common.collect.ImmutableList&lt;T&gt;&gt;</span>&nbsp;<span class="element-name">toImmutableList</span>()</div>
<div class="block">Returns a <code>Collector</code> that accumulates the input elements into a
 Guava <code>ImmutableList</code> via a <code>ImmutableList.Builder</code>.

 <p>It will be obsolete when we move to <a href="Bug.html#upgrade(java.lang.String)"><code>Guava 28.0-jre</code></a>.
 Guava 21.0 introduced <code>ImmutableList.toImmutableList()</code>, but it had
 a <code>Beta</code> tag until 28.0-jre.

 <p>In <a href="Bug.html#upgrade(java.lang.String)"><code>Guava 21.0</code></a>, change this method to call
 <code>ImmutableList.toImmutableList()</code>, ignoring the <code>@Beta</code> tag.</div>
<dl class="notes">
<dt>Type Parameters:</dt>
<dd><code>T</code> - Type of the input elements</dd>
<dt>Returns:</dt>
<dd>a <code>Collector</code> that collects all the input elements into an
 <code>ImmutableList</code>, in encounter order</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="combine(com.google.common.collect.ImmutableList.Builder,com.google.common.collect.ImmutableList.Builder)">
<h3>combine</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>
<span class="return-type">com.google.common.collect.ImmutableList.Builder&lt;E&gt;</span>&nbsp;<span class="element-name">combine</span><wbr><span class="parameters">(com.google.common.collect.ImmutableList.Builder&lt;E&gt;&nbsp;b0,
 com.google.common.collect.ImmutableList.Builder&lt;E&gt;&nbsp;b1)</span></div>
<div class="block">Combines a second immutable list builder into a first.</div>
</section>
</li>
<li>
<section class="detail" id="combine(java.util.ArrayList,java.util.ArrayList)">
<h3>combine</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/ArrayList.html" title="class or interface in java.util" class="external-link">ArrayList</a>&lt;E&gt;</span>&nbsp;<span class="element-name">combine</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/ArrayList.html" title="class or interface in java.util" class="external-link">ArrayList</a>&lt;E&gt;&nbsp;list0,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/ArrayList.html" title="class or interface in java.util" class="external-link">ArrayList</a>&lt;E&gt;&nbsp;list1)</span></div>
<div class="block">Combines a second array list into a first.</div>
</section>
</li>
<li>
<section class="detail" id="andThen(java.util.function.UnaryOperator,java.util.function.UnaryOperator)">
<h3>andThen</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;X&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/UnaryOperator.html" title="class or interface in java.util.function" class="external-link">UnaryOperator</a>&lt;X&gt;</span>&nbsp;<span class="element-name">andThen</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/UnaryOperator.html" title="class or interface in java.util.function" class="external-link">UnaryOperator</a>&lt;X&gt;&nbsp;op1,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/UnaryOperator.html" title="class or interface in java.util.function" class="external-link">UnaryOperator</a>&lt;X&gt;&nbsp;op2)</span></div>
<div class="block">Returns an operator that applies <code>op1</code> and then <code>op2</code>.

 <p>As <a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/Function.html#andThen(java.util.function.Function)" title="class or interface in java.util.function" class="external-link"><code>Function.andThen(Function)</code></a> but for <a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/UnaryOperator.html" title="class or interface in java.util.function" class="external-link"><code>UnaryOperator</code></a>.</div>
</section>
</li>
<li>
<section class="detail" id="transform(java.util.List,java.util.function.Function)">
<h3>transform</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;F,<wbr>
T&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;T&gt;</span>&nbsp;<span class="element-name">transform</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends F&gt;&nbsp;list,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/Function.html" title="class or interface in java.util.function" class="external-link">Function</a>&lt;? super F,<wbr>? extends T&gt;&nbsp;function)</span></div>
<div class="block">Transforms a list, applying a function to each element.</div>
</section>
</li>
<li>
<section class="detail" id="transformIndexed(java.util.List,java.util.function.BiFunction)">
<h3>transformIndexed</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;F,<wbr>
T&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;T&gt;</span>&nbsp;<span class="element-name">transformIndexed</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends F&gt;&nbsp;list,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/BiFunction.html" title="class or interface in java.util.function" class="external-link">BiFunction</a>&lt;? super F,<wbr><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>,<wbr>? extends T&gt;&nbsp;function)</span></div>
<div class="block">Transforms a list, applying a function to each element, also passing in
 the element's index in the list.</div>
</section>
</li>
<li>
<section class="detail" id="transform(java.lang.Iterable,java.util.function.Function)">
<h3>transform</h3>
<div class="member-signature"><span class="annotations">@API(since="1.27",
     status=EXPERIMENTAL)
</span><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;F,<wbr>
T&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;T&gt;</span>&nbsp;<span class="element-name">transform</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;? extends F&gt;&nbsp;iterable,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/Function.html" title="class or interface in java.util.function" class="external-link">Function</a>&lt;? super F,<wbr>? extends T&gt;&nbsp;function)</span></div>
<div class="block">Transforms an iterable, applying a function to each element.</div>
</section>
</li>
<li>
<section class="detail" id="transform(java.util.Iterator,java.util.function.Function)">
<h3>transform</h3>
<div class="member-signature"><span class="annotations">@API(since="1.27",
     status=EXPERIMENTAL)
</span><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;F,<wbr>
T&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/Iterator.html" title="class or interface in java.util" class="external-link">Iterator</a>&lt;T&gt;</span>&nbsp;<span class="element-name">transform</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/Iterator.html" title="class or interface in java.util" class="external-link">Iterator</a>&lt;? extends F&gt;&nbsp;iterator,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/Function.html" title="class or interface in java.util.function" class="external-link">Function</a>&lt;? super F,<wbr>? extends T&gt;&nbsp;function)</span></div>
<div class="block">Transforms an iterator.</div>
</section>
</li>
<li>
<section class="detail" id="filter(java.lang.Iterable,java.util.function.Predicate)">
<h3>filter</h3>
<div class="member-signature"><span class="annotations">@API(since="1.27",
     status=EXPERIMENTAL)
</span><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;E&gt;</span>&nbsp;<span class="element-name">filter</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Iterable.html" title="class or interface in java.lang" class="external-link">Iterable</a>&lt;? extends E&gt;&nbsp;iterable,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/Predicate.html" title="class or interface in java.util.function" class="external-link">Predicate</a>&lt;? super E&gt;&nbsp;predicate)</span></div>
<div class="block">Filters an iterable.</div>
</section>
</li>
<li>
<section class="detail" id="filter(java.util.Iterator,java.util.function.Predicate)">
<h3>filter</h3>
<div class="member-signature"><span class="annotations">@API(since="1.27",
     status=EXPERIMENTAL)
</span><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/Iterator.html" title="class or interface in java.util" class="external-link">Iterator</a>&lt;E&gt;</span>&nbsp;<span class="element-name">filter</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/Iterator.html" title="class or interface in java.util" class="external-link">Iterator</a>&lt;? extends E&gt;&nbsp;iterator,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/Predicate.html" title="class or interface in java.util.function" class="external-link">Predicate</a>&lt;? super E&gt;&nbsp;predicate)</span></div>
<div class="block">Filters an iterator.</div>
</section>
</li>
<li>
<section class="detail" id="moveToHead(java.util.List,java.util.function.Predicate)">
<h3>moveToHead</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;</span>&nbsp;<span class="element-name">moveToHead</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;? extends E&gt;&nbsp;terms,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/function/Predicate.html" title="class or interface in java.util.function" class="external-link">Predicate</a>&lt;? super E&gt;&nbsp;predicate)</span></div>
<div class="block">Returns a list with any elements for which the predicate is true moved to
 the head of the list. The algorithm does not modify the list, is stable,
 and is idempotent.</div>
</section>
</li>
<li>
<section class="detail" id="select(java.util.List,java.util.List)">
<h3>select</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;E&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;</span>&nbsp;<span class="element-name">select</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;E&gt;&nbsp;list,
 <a href="https://docs.oracle.com/javase/9/docs/api/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="https://docs.oracle.com/javase/9/docs/api/java/lang/Integer.html" title="class or interface in java.lang" class="external-link">Integer</a>&gt;&nbsp;ordinals)</span></div>
<div class="block">Returns a view of a list, picking the elements of a list with the given
 set of ordinals.</div>
</section>
</li>
<li>
<section class="detail" id="blackholeMap()">
<h3>blackholeMap</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="type-parameters">&lt;K,<wbr>
V&gt;</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/javase/9/docs/api/java/util/Map.html" title="class or interface in java.util" class="external-link">Map</a>&lt;K,<wbr>V&gt;</span>&nbsp;<span class="element-name">blackholeMap</span>()</div>
<div class="block">Returns a map which ignores any write operation.</div>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Copyright &copy; 2012-2022 Apache Software Foundation. All Rights Reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
