Here you can find the source of endsWithIgnoreCase(String a, String b)
true if a ends with b regardless of the case.
| Parameter | Description |
|---|---|
| a | string to test. |
| b | suffix to test for. |
true if a ends with b regardless of the case, false otherwise.
public static boolean endsWithIgnoreCase(String a, String b)
//package com.java2s; /*/* ww w .j a v a 2 s. c o m*/ * This file is part of muCommander, http://www.mucommander.com * Copyright (C) 2002-2010 Maxence Bernard * * muCommander is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 3 of the License, or * (at your option) any later version. * * muCommander is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. */ public class Main { /** * Returns <code>true</code> if <code>a</code> ends with <code>b</code> regardless of the case. * <p> * This method has a known bug under some alphabets with peculiar capitalisation rules such as the Georgian one, * where <code>Character.toUpperCase(a) == Character.toUpperCase(b)</code> doesn't necessarily imply that * <code>Character.toLowerCase(a) == Character.toLowerCase(b)</code>. The performance hit of testing for this * exceptions is so huge that it was deemed an acceptable issue. * </p> * <p> * Note that this method will return <code>true</code> if <code>b</code> is an emptry string. * </p> * @param a string to test. * @param b suffix to test for. * @return <code>true</code> if <code>a</code> ends with <code>b</code> regardless of the case, <code>false</code> otherwise. */ public static boolean endsWithIgnoreCase(String a, String b) { return matchesIgnoreCase(a, b, a.length()); } /** * Returns <code>true</code> if <code>a</code> ends with <code>b</code> regardless of the case. * <p> * This method has a known bug under some alphabets with peculiar capitalisation rules such as the Georgian one, * where <code>Character.toUpperCase(a) == Character.toUpperCase(b)</code> doesn't necessarily imply that * <code>Character.toLowerCase(a) == Character.toLowerCase(b)</code>. The performance hit of testing for this * exceptions is so huge that it was deemed an acceptable issue. * </p> * <p> * Note that this method will return <code>true</code> if <code>b</code> is an emptry string. * </p> * @param a string to test. * @param b suffix to test for. * @return <code>true</code> if <code>a</code> ends with <code>b</code> regardless of the case, <code>false</code> otherwise. */ public static boolean endsWithIgnoreCase(String a, char[] b) { return matchesIgnoreCase(a, b, a.length()); } /** * Returns <code>true</code> if the substring of <code>a</code> starting at <code>posA</code> matches <code>b</code> regardless of the case. * <p> * This method has a known bug under some alphabets with peculiar capitalisation rules such as the Georgian one, * where <code>Character.toUpperCase(a) == Character.toUpperCase(b)</code> doesn't necessarily imply that * <code>Character.toLowerCase(a) == Character.toLowerCase(b)</code>. The performance hit of testing for this * exceptions is so huge that it was deemed an acceptable issue. * </p> * <p> * Note that this method will return <code>true</code> if <code>b</code> is an emptry string. * </p> * @param a string to test. * @param b suffix to test for. * @param posA position in <code>a</code> at which to look for <code>b</code> * @return <code>true</code> if <code>a</code> ends with <code>b</code> regardless of the case, <code>false</code> otherwise.</code>. * @throws ArrayIndexOutOfBoundsException if <code>a.length</code> is smaller than <code>posA</code>. */ public static boolean matchesIgnoreCase(String a, String b, int posA) { int posB; // Position in b. char cA; // Current character in a. char cB; // Current character in b. // Checks whether there's any point in testing the strings. if (posA < (posB = b.length())) return false; // Loops until we've tested the whole of b. while (posB > 0) { // Works on lower-case characters only. if (!Character.isLowerCase(cA = a.charAt(--posA))) cA = Character.toLowerCase(cA); if (!Character.isLowerCase(cB = b.charAt(--posB))) cB = Character.toLowerCase(cB); if (cA != cB) return false; } return true; } /** * Returns <code>true</code> if the substring of <code>a</code> starting at <code>posA</code> matches <code>b</code> regardless of the case. * <p> * This method has a known bug under some alphabets with peculiar capitalisation rules such as the Georgian one, * where <code>Character.toUpperCase(a) == Character.toUpperCase(b)</code> doesn't necessarily imply that * <code>Character.toLowerCase(a) == Character.toLowerCase(b)</code>. The performance hit of testing for this * exceptions is so huge that it was deemed an acceptable issue. * </p> * <p> * Note that this method will return <code>true</code> if <code>b</code> is an emptry string. * </p> * @param a string to test. * @param b suffix to test for. * @param posA position in <code>a</code> at which to look for <code>b</code> * @return <code>true</code> if <code>a</code> ends with <code>b</code> regardless of the case, <code>false</code> otherwise.</code>. * @throws ArrayIndexOutOfBoundsException if <code>a.length</code> is smaller than <code>posA</code>. */ public static boolean matchesIgnoreCase(String a, char[] b, int posA) { int posB; // Position in b. char cA; // Current character in a. char cB; // Current character in b. // Checks whether there's any point in testing the strings. if (posA < (posB = b.length)) return false; while (posB > 0) { if (!Character.isLowerCase(cA = a.charAt(--posA))) cA = Character.toLowerCase(cA); if (!Character.isLowerCase(cB = b[--posB])) cB = Character.toLowerCase(cB); if (cA != cB) return false; } return true; } }